Evaluating the Feasibility of Adopting Models in Software Engineering Process

Evaluating the feasibility of adopting models in

Software engineering process

Abhilash

October 29, 2014

INTRODUCTION

        Today's systems are large. Large in the sense, the number of developers involved, functions and variants defined, classes and use cases used, lines of code written etc. These factors make the system complex. The cost of development of these systems is high. If errors are found in the system, then re-designing and synchronizing the re-written code is not economically feasible. For instance, if a new technology with better features are available in the market, then re-configuring the existing system becomes unmanageable.

        Instead, today's systems must be developed in a way to adopt the change that may occur in the future. This can be done by using models as primary artifacts. Through which additional extensions, modifications can be made when the change is needed in the future. By separating the design and the data or documentation the systems can accommodate change by enhancing the quality of the product(Özgür 2007).

        Complexity and lack of abstraction are the major challenges facing by software companies. Model Driven Development is growing and it has the capabilities to solve complex problems. It also leverages the ability to  develop product in less time and also decrease maintenance effort while increasing the quality of product. Many companies are showing interest to adopt MDD. Code generation or the computerization of the technical work is the main application of the MDD approaches. Moreover, this technology is also used in the assistance and automation of methodological practices.

        But, one cannot state that it ultimately supersedes writing code. Not all the firms which adopted this approach generated code successfully. It depends on the code generators used and it varies from one firm to another. Further study and development is needed to build such code generators which can supersede writing code.

CODE-CENTRIC TO MODEL DRIVEN DEVELOPMENT

        Software systems are complex in nature now-a-days. Adding features which are more capable and modifications to the existing software systems are the principal causes for the system's complexity. Existing systems must cope up with the new technologies which are in-demand in the market in this challenging world. By practicing the traditional approach, i.e., Code centric approach, developers face difficulties in re-writing the code to accommodate that change. The situation may become worse: 1)  If there are many developers working on that system, 2) If the developers are working from different locations.

        In this situation, there is no overall picture of the system for the developers, who work on individual tasks. The time consumed to synchronize all those individual tasks is more. The change can be classified in two ways. One is that which can be predicted. This type of change can be accepted which takes less time and also cost-effective. The second way is that which cannot be predicted. This type of change affects the system and it makes very difficult to re-configure the system and is economically not feasible. Using the traditional approach, this type of change cannot be adopted.

        Handling these type of challenges, needs an approach which includes domain-specific knowledge. Here comes the models in the picture. Model driven development raises the level of abstraction by separating the design and the data(Bettin 2004). In this type of approach models are the primary artifacts while the code and documentation are generated from models. By creating models the overall picture of the system is defined. This enhances the productivity and quality of the product. It requires less time and is cost-effective to accept the change. Since when the change is needed, only the models have been modified and the code is generated from models. The developers require to concentrate only on models which raises the level of abstraction by hiding the platform-specific implementations. Since each model implies lines of code it is transformed into a working software product(Mraidha, Robert et al. 2004). This makes to build a software with low cost since it demands less time and people.

ASSESSING THE FEASIBILITY OF MODEL DRIVEN DEVELOPMENT

        In order to assess the feasibility of applying models in software engineering process, I would like to demonstrate the influence of models on software products.

        Productivity: In general, it is defined as the production rate of goods or services produced by a company with respect to the employers involved and materials required. In this context, it is the production rate of software product produced by a company with respect to the developers or people involved and the tools.

        By applying models in the software engineering process productivity of the software product is increased. This can be explained by considering various factors into account. The time taken to develop code is reduced since the code is automatically generated from models. And also the time required to examine the generated code is reduced by using model based testing methods. The generated code has only few symantic errors(Krogmann and Becker 2007) which can be fixed in less time.

        Portability: Portability is defined as a factor which determines whether the software which is produced by a company works in different environments and the time required to migrate to a new environment. Different environments in the sense operating systems or the platforms. The time required to migrate to a new environment is reduced by applying models(Selmeryd 2012). This can done by applying few new sets of translations. The models are re-configured if migration is needed. By using this approach portability of the software product is increased.

        Maintenance: It is defined as a process of state of software being maintained. By applying models in software engineering process, the time required for stakeholders to understand each other is less. The new staff can easily understand the existing system. Moreover the code is automatically generated and there is no demand of new staff to enforce the code. The time required to maintain the software is also less because the traceability of the models is automatically done and the maintenance is starting from the initial stages.