A brief top-down and bottom-up philosophy on software evolution

Software reuse and evolution are problematic. Modules tend to express a great deal of knowledge about the external modules, large-scale structure, and behaviour of the systems in which they reside. As a result, the reusability of individual modules is decreased as they are too dependent on other modules. Likewise, the evolvability of systems is decreased as they are too dependent on the details of individual modules. However, we must have some dependences between our modules, or they would not be able to operate together. Not all dependences are equally bad, then. Each module can be seen to have a minimal core, an essential structure, beyond which it makes no sense to reduce. This essential structure describes the basic responsibilities of that module, and its expectations of the responsibilities of external modules. The thesis of this dissertation is that expressing the essential structure of our software modules, through the use of implicit context, makes those modules easier to reuse and the systems containing those modules easier to evolve. Implicit context revolves around the notion that we must abandon the need for all modules to be defined with respect to an absolute frame of reference. Instead, modules can be defined relative to a reference frame of convenience. In order for modules to work together, the inconsistencies in their independent world views must be reconciled when they attempt to communicate. Implicit context provides the novel mechanism of contextual dispatch to perform this reconciliation. When any communication passes into or out of a module, that communication may be rerouted, altered, replaced, or discarded altogether, as the situation dictates. This translation process sometimes requires access to information about the communication history of the system; objects previously passed can be retrieved, or the appropriate recipient of a message can be determined. The dissertation describes a prototype tool that supports the application of implicit context to Java source code. The thesis is validated by applying this tool in two case studies: comparing the evolution of an implicit context-based implementation of an FTP server to an object-oriented implementation; and reusing the Outline View of the Eclipse integrated development environment in a different application, even though the Outline View was not designed for such reuse.

It can be argued, that software development and game development share a number of features in their process models, such as the need to design, develop and test software functionalities. However, while the software engineering (SE) models work successfully supporting the software development, their practical application for game development is frequently unsuccessful. To understand this problem and number of other aspects such as Green IT and business models, we conducted a survey with the game industry organizations. Based on our observations on the SE practices, the game industry applies mostly the agile process models or nothing at all, their major concerns for business were mobile development, digital marketing, employees with specific abilities and keeping innovation in their business, and their minor concerns were eco-impact elements, software reusability and financing. Based on our results, we identified areas which would warrant more studies to support the game industry practices, eco-aspects and business.

In this paper, we identify a set of factors that may be used to forecast software productivity and software development time. Software productivity was measured in function points per person hours, and software development time was measured in number of elapsed days. Using field data on over 130 field software projects from various industries, we empirically test the impact of team size, integrated computer aided software engineering (ICASE) tools, software development type, software development platform, and programming language type on the software development productivity and development time. Our results indicate that team size, software development type, software development platform, and programming language type significantly impact software development productivity. However, only team size significantly impacts software development time. Our results indicate that effective management of software development teams, and using different management strategies for different software development type environments may improve software development productivity.

Pengembangan perangkat lunak adalah tugas kompleks dan membutuhkan adaptasi untuk mengakomodasi kebutuhan pengguna. Untuk membuat konsep dan perubahan perangkat lunak, dalam pemeliharaan, sekarang telah dikembangkan lebih mudah dalam pengembangan perangkat lunak, pola model-view-controller, yang merupakan arsitektur yang dapat membantu memfasilitasi dalam pengembangan dan pemeliharaan perangkat luna. Hal ini, karena dalam arsitektur model tiga-lapis, yaitu: tampilan dan pengontrolan dalam pembangunan dilakukan secara independen, sehingga dapat memberikan dahan dalam pengembangan dan pemeliharaan. Selain itu, arsitektur ini juga dapat melihat hal-hal yang sederhana dan menarik bagi pengguna. Software sistem on-line test adalah perangkat lunak yang memerlukan interaksi dengan pengguna, dan pemeliharaan perangkat adaptif. Karena sistem ujian on-line memerlukan pengembangan perangkat lunak untuk mengakomodasi kebutuhan ini berkembang dengan cepat. Makalah ini untuk menganalisis Model-View-Controller dan mencoba pembangunan, untuk menerapkannya dalam pengembangan perangkat lunak sistem pengujian on-line.

Software testing is an important process in software quality assurance(SQA). Software testing consumes the majority of the software developers' time and cost of all the phases of system development. An important problem in software testing is to determine whether a program has been tested enough with a testing criterion and when one could stop testing. On the other hand, software measurement is used to estimate the quality of a software. Complexity measures can be used to compare software quality and development cost. This paper proposes a new testing approach which choosing testing path based on path complexity. The process is to use a set of testing paths that satisfying all-uses testing criterion, and then choose the testing path with the most complexity to test. This process is continued until the program can be accepted. The proposed formula is used to determine if it is possible to stop testing before satisfying all-du-paths testing criterion. The main contribution of the paper is that software developers can choose a proper testing action with lower testing effort.

Based on a preventive, development-before-the-fact philosophy that does not allow errors in the first place, the Universal Systems Language has evolved over several decades, offering system engineers and software developers a language they can use to solve problems previously considered next to impossible to solve with traditional approaches.

The topic of this thesis is the analysis of the evolution of software components. In order to track the evolution of software components, one needs to collect the evolution information of each component. This information is stored in the version control system (VCS) of the project—the repository of the history of events happening throughout the project’s lifetime. By using software archive mining techniques one can extract and leverage this information. The main contribution of this thesis is the introduction of evolution usage trends and evolution change patterns. The raw information about the occurrences of each component is stored in the VCS of the project. By organizing it in evolution trends and patterns, we are able to draw conclusions and issue recommendations concerning each individual component and the project as a whole.

Software Engineering courses are perceived as being dry and boring. The education community has been looking at active learning and hands-on training techniques to engage students better and thereby provide a better understanding of concepts. This paper presents a web-based game called Scrumify, developed by undergraduate students, that is designed to introduce students to the Scrum software development process through story elements, and quiz mechanics. The game is designed to reinforce software engineering concepts more specifically agile software processes. Quizzes within the game are designed to grant points that inject a sense of competition for the users and motivation to learn the agile methodology concepts. Scrumify serves two objectives: software engineering education for audience of the game and web-based game development and software testing education for the developers of the game. Use of this game in classroom provides an active learning technique for agile software processes. Students are more engaged with games and thereby absorb the concepts better. The game was evaluated in a sophomore software engineering class and the results are presented.

The purpose of this research was to develop and apply a systems-based framework for the analysis of software development project performance. Software development project performance is measured at the project level; that is, cost, schedule, and product quality that affect the overall project. To date, most performance improvement efforts have been focused on individual processes within the overall software development system. Making improvements to sub-elements, processes, or sub-systems without regard for the overall project is a classic misbehavior entered into by practitioners who fail to use a holistic, systemic approach. Attempts to improve sub-system behavior are at odds with The Principle of Sub-optimization. (van Gigch, 1974) The traditional method of predicting software development project performance, in terms of sub-system performance is too restrictive. A new holistic, systemic view based on systems principles offers a more robust way to look at performance. This research addressed this gap in the systems and software body of knowledge by developing a generalizable and transportable framework for software project performance that is based on systems principles. A rigorous mixed-method research methodology, employing both inductive and case study methods, was used to develop and validate the framework. Two research questions were identified as integral to increasing the understanding of a systems-based framework. (1) How does systems theory apply to the analysis of software development project performance? (2) What results from the application of a systems-based analysis framework for analyzing performance on a software development project? Using Discoverers' Induction (Whewell, 1858), a systems-based framework for the analysis of software development project performance was constructed, adding to the systems and software body of knowledge and substantiating a comprehensive and unambiguous theoretical construct for software development. Then, the framework was applied to two completed software development projects to support validation. The structured systemic framework shows significant promise for contribution to software practitioners by indicating future software development project performance. The research also made a contribution in the area of research methodologies by resurrecting William Whewell's Discoverers' Induction (1858) and furthering the use of the case study method in the engineering management and systems engineering domain, areas where their application has been very limited.

The benefits of impact analysis in the maintenance and evolution of software systems are well known, and many forms of impact analysis, over different software life cycle objects, have been proposed. However, one form of impact from software change has yet to be explored by the research community: these are the impacts of changes to software on data. In particular, when the business rules enforced by a system change, it may be necessary to perform some cleanup or transformations on persistent data, in order to bring it into line with the new system functionality. Alternatively, the proposed new rule may itself have to be modified, if the data impacts are too costly to address. In this paper, we show how such impacts can arise, and propose an approach to assisting in their identification through user-driven exploration of hypothetical change-impact scenarios.

Context: Successful software systems continuously evolve to accommodate feature requests of a diverse customer-base. At some point during this evolution, the variety of customer needs and increased system complexity suggests the consideration of a software product line (SPL).Aim: The goal of this research is to support the decision maker facing the enhancement of an evolving software system (ESS) by determining the most appropriate product line design (out of a given set of candidate SPL portfolios) to minimize the technical risk and maximize the business value.Method: The proposed method called OPTESS is aimed at finding an evolution plan for the ESS which optimizes both the given technical and business objectives. Business analysis using a value-based pricing mechanism is applied to a set of initially proposed SPL portfolios (for enhancing the ESS) such that profit is maximized. Technical analysis is applied to the same initially proposed SPL portfolios to minimize the risk of failure of ESS due to implementation of new features. Business and technical analyses improve the performance of solutions for their respective objectives by modifying the feature sets of candidate SPL portfolios. OPTESS helps the decision maker select a plan for enhancement of an ESS by performing trade- off analysis between economic and technical objectives.Results: The method was initially evaluated through a case study for a set of 9 new candidate features to be added to an open source text editing system called jEdit. OPTESS helped the decision maker to identify 3 non-dominated solutions judged to be the best contenders for addition when considering both technical and economic criteria.

Identifying a strategy for legacy software system evolution requires analysis and assessment activities. Information on performance and costs of software systems must be considered when making decisions on the most suitable strategy to be applied. Many approaches have been defined for supporting this task, and several authors have proposed decision frameworks for aiding the selection of evolution strategy. These approaches often lack of techniques for the management of uncertainty, traditionally considered as unscientific and as a source of errors and arising from the confidence of the answers provided by respondents. An approach previously proposed is analyzed and extended with fuzzy logic concepts. The approach uses a measurement framework based on the Goal-Question-Metric (GQM) paradigm and a set of critiquing tables. Fuzzy logic principles have been introduced in both components, for obtaining a better insight of the analyzed software system quality and an indication of the risks to be assumed when one selected strategy is adopted instead of another.

Function point analysis is a widely cited method for estimating software project size, which is an important activity of project management. At the beginning stage of planning, the top-down approach can be applied. Having obtained more systems specifications at later stages, the bottom-up approach might also be used to improve the accuracy of the estimation. However, the bottom-up approach is not a conventional way of function point analysis. There was no empirical evidence showing the difference between the fully informed top-down approach and the bottom-up approach. Through the implementation of a function point analysis system in an in-house software development department, this paper compares the results of the two approaches. This comparison study shows that the bottom-up approach does not contribute a significant added value to a fully-informed top-down approach. Therefore, the fully-informed top down approach has been chosen as a method for building a software metric database in the organization. More important, the observations and experience gained from this project may help in-house development organizations to establish their own function point analysis systems.

The quality assurance of software product lines (SPL) achieved via testing is a crucial and challenging activity of SPL engineering. In general, the application of single-software testing techniques for SPL testing is not practical as it leads to the individual testing of a potentially vast number of variants. Testing each variant in isolation further results in redundant testing processes by means of redundant test-case executions due to the shared commonality. Existing techniques for SPL testing cope with those challenges, e.g., by identifying samples of variants to be tested. However, each variant is still tested separately without taking the explicit knowledge about the shared commonality and variability into account to reduce the overall testing effort. Furthermore, due to the increasing longevity of software systems, their development has to face software evolution. Hence, quality assurance has also to be ensured after SPL evolution by testing respective versions of variants. In this thesis, we tackle the challenges of testing redundancy as well as evolution by proposing a framework for model-based regression testing of evolving SPLs. The framework facilitates efficient incremental testing of variants and versions of variants by exploiting the commonality and reuse potential of test artifacts and test results. Our contribution is divided into three parts. First, we propose a test-modeling formalism capturing the variability and version information of evolving SPLs in an integrated fashion. The formalism builds the basis for automatic derivation of reusable test cases and for the application of change impact analysis to guide retest test selection. Second, we introduce two techniques for incremental change impact analysis to identify (1) changing execution dependencies to be retested between subsequently tested variants and versions of variants, and (2) the impact of an evolution step to the variant set in terms of modified, new and unchanged versions of variants. Third, we define a coverage-driven retest test selection based on a new retest coverage criterion that incorporates the results of the change impact analysis. The retest test selection facilitates the reduction of redundantly executed test cases during incremental testing of variants and versions of variants. The framework is prototypically implemented and evaluated by means of three evolving SPLs showing that it achieves a reduction of the overall effort for testing evolving SPLs.

Software metrics are measures of software. Their primary use is to help us plan and predict software development. We can better control software quality and development effort if we can quantify the software. This is especially true in the early stages of development. Research has been done in the area of predicting software maintenance effort from software metrics. In general, software metrics can be classified into two categories: software product metrics and software process metrics. Software product metrics are measures of software products such as source code and design documents. Software process metrics are measures of software development process. For example, the size of the software is a measure of the software product itself, thus a product metrics. The effort required to design a software system may be influenced by how the software is designed, thus a process metrics. In this article, only software product metrics are addressed.