Abstract: Model transformation, as a pivotal aspect of Modeldriven
engineering, attracts more and more attentions both from
researchers and practitioners. Many domains (enterprise engineering,
software engineering, knowledge engineering, etc.) use model
transformation principles and practices to serve to their domain
specific problems; furthermore, model transformation could also be
used to fulfill the gap between different domains: by sharing and
exchanging knowledge. Since model transformation has been widely
used, there comes new requirement on it: effectively and efficiently
define the transformation process and reduce manual effort that
involved in. This paper presents an automatic model transformation
methodology based on semantic and syntactic comparisons, and
focuses particularly on granularity issue that existed in transformation
process. Comparing to the traditional model transformation
methodologies, this methodology serves to a general purpose: crossdomain
methodology. Semantic and syntactic checking
measurements are combined into a refined transformation process,
which solves the granularity issue. Moreover, semantic and syntactic
comparisons are supported by software tool; manual effort is replaced
in this way.
Abstract: All the software engineering researches and best
industry practices aim at providing software products with high
degree of quality and functionality at low cost and less time. These
requirements are addressed by the Component Based Software
Engineering (CBSE) as well. CBSE, which deals with the software
construction by components’ assembly, is a revolutionary extension
of Software Engineering. CBSE must define and describe processes
to assure timely completion of high quality software systems that are
composed of a variety of pre built software components. Though
these features provide distinct and visible benefits in software design
and programming, they also raise some challenging problems. The
aim of this work is to summarize the pertinent issues and
considerations in CBSE to make an understanding in forms of
concepts and observations that may lead to development of newer
ways of dealing with the problems and challenges in CBSE.
Abstract: This paper describes the tradeoffs and the design from
scratch of a self-contained, easy-to-use health dashboard software
system that provides customizable data tracking for patients in smart
homes. The system is made up of different software modules and
comprises a front-end and a back-end component. Built with HTML,
CSS, and JavaScript, the front-end allows adding users, logging into
the system, selecting metrics, and specifying health goals. The backend
consists of a NoSQL Mongo database, a Python script, and a
SimpleHTTPServer written in Python. The database stores user
profiles and health data in JSON format. The Python script makes use
of the PyMongo driver library to query the database and displays
formatted data as a daily snapshot of user health metrics against
target goals. Any number of standard and custom metrics can be
added to the system, and corresponding health data can be fed
automatically, via sensor APIs or manually, as text or picture data
files. A real-time METAR request API permits correlating weather
data with patient health, and an advanced query system is
implemented to allow trend analysis of selected health metrics over
custom time intervals. Available on the GitHub repository system,
the project is free to use for academic purposes of learning and
experimenting, or practical purposes by building on it.
Abstract: Through this paper we present a method for automatic
generation of ontological model from any data source using Model
Driven Architecture (MDA), this generation is dedicated to the
cooperation of the knowledge engineering and software engineering.
Indeed, reverse engineering of a data source generates a software
model (schema of data) that will undergo transformations to generate
the ontological model. This method uses the meta-models to validate
software and ontological models.
Abstract: Developing a reliable and sustainable software products is today a big challenge among up–coming software developers in Nigeria. The inability to develop a comprehensive problem statement needed to execute proper requirements engineering process is missing. The need to describe the ‘what’ of a system in one document, written in a natural language is a major step in the overall process of Software Engineering. Requirements Engineering is a process use to discover, analyze and validate system requirements. This process is needed in reducing software errors at the early stage of the development of software. The importance of each of the steps in Requirements Engineering is clearly explained in the context of using detailed problem statement from client/customer to get an overview of an existing system along with expectations from the new system. This paper elicits inadequate Requirements Engineering principle as the major cause of poor software development in developing nations using a case study of final year computer science students of a tertiary-education institution in Nigeria.
Abstract: Traditional software engineering allows engineers to propose to their clients multiple specialized software distributions assembled from a shared set of software assets. The management of these assets however requires a trade-off between client satisfaction and software engineering process. Clients have more and more difficult to find a distribution or components based on their needs from all of distributed repositories.
This paper proposes a software engineering for a user-driven software product line in which engineers define a Feature Model but users drive the actual software distribution on demand. This approach makes the user become final actor as a release manager in software engineering process, increasing user product satisfaction and simplifying user operations to find required components. In addition, it provides a way for engineers to manage and assembly large software families.
As a proof of concept, a user-driven software product line is implemented for Eclipse, an integrated development environment. An Eclipse feature model is defined, which is exposed to users on a cloud-based built platform from which clients can download individualized Eclipse distributions.
Abstract: This paper proposes a new teaching and learning approach-project and module based teaching and learning (PMBTL). The PMBTL approach incorporates the merits of project/problem based and module based learning methods, and overcomes the limitations of these methods. The correlation between teaching, learning, practice and assessment is emphasized in this approach, and new methods have been proposed accordingly. The distinct features of these new methods differentiate the PMBTL approach from conventional teaching approaches. Evaluation of this approach on practical teaching and learning activities demonstrates the effectiveness and stability of the approach in improving the performance and quality of teaching and learning. The approach proposed in this paper is also intuitive to the design of other teaching units.
Abstract: Mobile applications are verified to check the correctness or evaluated to check the performance with respect to specific security properties such as Availability, Integrity and Confidentiality. Where they are made available to the end users of the mobile application is achievable only to a limited degree using software engineering static verification techniques. The more sensitive the information, such as credit card data, personal medical information or personal emails being processed by mobile application, the more important it is to ensure the confidentiality of this information. Monitoring untrusted mobile application during execution in an environment where sensitive information is present is difficult and unnerving. The paper addresses the issue of monitoring and controlling the flow of confidential information during untrusted mobile application execution. The approach concentrates on providing a dynamic and usable information security solution by interacting with the mobile users during the runtime of mobile application in response to information flow events.
Abstract: Defect prevention is the most vital but habitually
neglected facet of software quality assurance in any project. If
functional at all stages of software development, it can condense the
time, overheads and wherewithal entailed to engineer a high quality
product. The key challenge of an IT industry is to engineer a
software product with minimum post deployment defects.
This effort is an analysis based on data obtained for five selected
projects from leading software companies of varying software
production competence. The main aim of this paper is to provide
information on various methods and practices supporting defect
detection and prevention leading to thriving software generation. The
defect prevention technique unearths 99% of defects. Inspection is
found to be an essential technique in generating ideal software
generation in factories through enhanced methodologies of abetted
and unaided inspection schedules. On an average 13 % to 15% of
inspection and 25% - 30% of testing out of whole project effort time
is required for 99% - 99.75% of defect elimination.
A comparison of the end results for the five selected projects
between the companies is also brought about throwing light on the
possibility of a particular company to position itself with an
appropriate complementary ratio of inspection testing.
Abstract: Web-based systems have become increasingly
important due to the fact that the Internet and the World Wide Web
have become ubiquitous, surpassing all other technological
developments in our history. The Internet and especially companies
websites has rapidly evolved in their scope and extent of use, from
being a little more than fixed advertising material, i.e. a "web
presences", which had no particular influence for the company's
business, to being one of the most essential parts of the company's
core business.
Traditional software engineering approaches with process models
such as, for example, CMM and Waterfall models, do not work very
well since web system development differs from traditional
development. The development differs in several ways, for example,
there is a large gap between traditional software engineering designs
and concepts and the low-level implementation model, many of the
web based system development activities are business oriented (for
example web application are sales-oriented, web application and
intranets are content-oriented) and not engineering-oriented.
This paper aims to introduce Increment Iterative extreme
Programming (IIXP) methodology for developing web based
systems. In difference to the other existence methodologies, this
methodology is combination of different traditional and modern
software engineering and web engineering principles.
Abstract: The fast growth in complexity coupled with requests for shorter development periods for embedded systems are bringing demands towards a more effective, i.e. higher-abstract, design process for hardaware/software integrated design. In Software Engineering area, Model Driven Architecture (MDA) and Executable UML (xUML) has been accepted to bring further improvement in software design. This paper constructs MDA and xUML stepwise transformations from an abstract specification model to a more concrete implementation model using the refactoring technique for hardaware/software integrated design. This approach provides clear and structured models which enables quick exploration and synthesis, and early stage verification.
Abstract: Program slicing is the task of finding all statements in
a program that directly or indirectly influence the value of a variable
occurrence. The set of statements that can affect the value of a
variable at some point in a program is called a program backward
slice. In several software engineering applications, such as program
debugging and measuring program cohesion and parallelism, several
slices are computed at different program points. The existing
algorithms for computing program slices are introduced to compute a
slice at a program point. In these algorithms, the program, or the
model that represents the program, is traversed completely or
partially once. To compute more than one slice, the same algorithm
is applied for every point of interest in the program. Thus, the same
program, or program representation, is traversed several times.
In this paper, an algorithm is introduced to compute all forward
static slices of a computer program by traversing the program
representation graph once. Therefore, the introduced algorithm is
useful for software engineering applications that require computing
program slices at different points of a program. The program
representation graph used in this paper is called Program Dependence
Graph (PDG).
Abstract: Transnational corporations (TNCs) are playing a major role in global R&D, not only through activities in their home countries but also increasingly abroad. However, the process of R&D offshoring is not yet discussed thoroughly. Based on in-depth case study on Agilent China Communications Operation, this paper presents a stage model for theorizing the R&D offshoring process. This stage model outlines 5 maturity levels of organization and the offshoring process: Subsidiary team, Mirror team, Independent team, Mirror sector and the Independent sector (from software engineering point of view, it is similar to the local team's capability level of maturity model). Moreover, the paper gives a detailed discussion on the relevant characteristics, as well as the ability/responsibility of transfer, priorities and the corresponding organization structure. It also gives the characteristics and key points of different level-s R&D offshoring implementation using actual team practice.
Abstract: Process improvements have drawn much attention in
practical software engineering. The capability maturity levels from
CMMI have become an important index to assess a software company-s
software engineering capability. However, in countries like
Taiwan, customers often have no choices but to deal with vendors that
are not CMMI prepared or qualified. We call these vendors maturitylevel-
1 (ML1) vendors. In this paper, we describe our experience
from consulting an e-school project. We propose an approach to help
our client tackle the ML1 vendors. Through our system analysis, we
produce a design. This design is suggested to be used as part of
contract and a blueprint to guide the implementation.
Abstract: The productivity of software development is one of the major concerns for project managers. Given the increasing complexity of the software being developed and the concomitant rise in the typical project size, the productivity has not consistently improved. By analyzing the latest release of ISBSG data repository with 4106 projects ever developed, we report on the factors found to significantly influence productivity, and present an original model for the estimation of productivity during project design. We further illustrate that software development productivity has experienced irregular variations between the years 1995 and 2005. Considering the factors significant to productivity, we found its variations are primarily caused by the variations of average team size for the development and the unbalanced use of the less productive development language 3GL.
Abstract: Source code retrieval is of immense importance in the software engineering field. The complex tasks of retrieving and extracting information from source code documents is vital in the development cycle of the large software systems. The two main subtasks which result from these activities are code duplication prevention and plagiarism detection. In this paper, we propose a Mohamed Amine Ouddan, and Hassane Essafi source code retrieval system based on two-level fingerprint representation, respectively the structural and the semantic information within a source code. A sequence alignment technique is applied on these fingerprints in order to quantify the similarity between source code portions. The specific purpose of the system is to detect plagiarism and duplicated code between programs written in different programming languages belonging to the same class, such as C, Cµ, Java and CSharp. These four languages are supported by the actual version of the system which is designed such that it may be easily adapted for any programming language.
Abstract: The development and use of mobile devices as well as its integration within education systems to deliver electronic contents and to support real-time communications was the focus of this research. In order to investigate the software engineering issues in using mobile devices a research on electronic content was initiated. The Developed MP3 mobile software solution was developed as a prototype for testing and developing a strategy for designing a usable m-learning environment. The mobile software solution was evaluated using mobile device using the link: http://projects.seeu.edu.mk/mlearn. The investigation also tested the correlation between the two mobile learning indicators: electronic content and attention, based on the Task Based learning instructional method. The mobile software solution ''M-Learn“ was developed as a prototype for testing the approach and developing a strategy for designing usable m-learning environment. The proposed methodology is about what learning modeling approach is more appropriate to use when developing mobile learning software.
Abstract: Design patterns describe good solutions to common
and reoccurring problems in program design. Applying design
patterns in software design and implementation have significant
effects on software quality metrics such as flexibility, usability,
reusability, scalability and robustness. There is no standard rule for
using design patterns. There are some situations that a pattern is
applied for a specific problem and this pattern uses another pattern.
In this paper, we study the effect of using chain of patterns on
software quality metrics.
Abstract: Measuring the complexity of software has been an
insoluble problem in software engineering. Complexity measures can
be used to predict critical information about testability, reliability,
and maintainability of software systems from automatic analysis of
the source code. During the past few years, many complexity
measures have been invented based on the emerging Cognitive
Informatics discipline. These software complexity measures,
including cognitive functional size, lend themselves to the approach
of the total cognitive weights of basic control structures such as loops
and branches. This paper shows that the current existing calculation
method can generate different results that are algebraically
equivalence. However, analysis of the combinatorial meanings of this
calculation method shows significant flaw of the measure, which also
explains why it does not satisfy Weyuker's properties. Based on the
findings, improvement directions, such as measures fusion, and
cumulative variable counting scheme are suggested to enhance the
effectiveness of cognitive complexity measures.
Abstract: Software engineering education not only embraces
technical skills of software development but also necessitates
communication and interaction among learners. In this paper, it is
proposed to adapt the PBL methodology that is especially designed to
be integrated into software engineering classroom in order to promote
collaborative learning environment. This approach helps students
better understand the significance of social aspects and provides a
systematic framework to enhance teamwork skills. The adaptation of
PBL facilitates the transition to an innovative software development
environment where cooperative learning can be actualized.