@article{boehm06crosstalk, title = {21st Century Processes for Acquiring 21st Century Software-Intensive Systems of Systems}, author = {Barry Boehm and Jo Ann Lane}, journal = {Crosstalk: Journal of Defence Software Engineering}, month = {May}, year = 2006, url = {http://www.stsc.hill.af.mil/crosstalk/2006/05/0605BoehmLane.html}, abstract = {Our experiences in helping to define, acquire, develop, and assess 21st century software-intensive systems of systems (SISOS) have taught us that traditional 20th century acquisition and development processes do not work well on such systems. This article summarizes the characteristics of such systems, and indicates the major problem areas in using traditional processes on them. We also present new processes that we and others have been developing, applying, and evolving to address 21st century SISOS. These include extensions to the risk-driven spiral model to cover broad (many systems), deep (many supplier levels), and long (many increments) acquisitions needing rapid fielding, high assurance, adaptability to high-change traffic, and complex interactions with evolving commercial off-the-shelf products, legacy systems, and external systems. }, biburl = {http://www.bibsonomy.org/bibtex/21f8ee50a8b956cd3ef957867b6bc3c49/neilernst}, keywords = {software systems} } @incollection{rommes06, title = {A Scenario-Based Method for Software Product Line Architecting}, address = {Berlin}, author = {Eelco Rommes and Pierre America}, booktitle = {Software Product Lines - Research Issues in Engineering and Management}, editor = {Timo Käkölä and Juan C. Dueñas}, pages = {3--52}, publisher = {Springer }, year = 2006, url = {http://dx.doi.org/10.1007/978-3-540-33253-4}, isbn = {978-3-540-33252-7}, description = {MetaPress - Book Chapter}, abstract = {Software product line engineering implies making a long-term investment in a common architecture. This architecture must support the derivation of potentially many generations of products in the line. Short-term and long-term business considerations should be well balanced when defining and evolving software product line architectures. Established methods for architecting lack support for doing this in an efficient manner. We present a scenariobased architecting method that addresses this problem. The method uses various types of scenario to ensure that the long-term future is taken into account, and to enable the efficient description, evaluation and comparison of multiple candidate architectures in parallel.}, biburl = {http://www.bibsonomy.org/bibtex/2b2f51f6db64467f11e7c2b18fb108ced/neilernst}, keywords = {product scenario software line} } @article{chapin01, title = {Types of software evolution and software maintenance}, author = {Ned Chapin and Joanne E. Hale and Juan Fernandez-Ramil and Wui-Gee Tan}, journal = {Journal of Software Maintenance and Evolution: Research and Practice}, number = 1, pages = {3--30}, publisher = {John Wiley \& Sons, Ltd.}, volume = 13, year = 2001, url = {http://dx.doi.org/10.1002/smr.220}, id = {606026}, priority = {3}, doi = {10.1002/smr.220}, description = {Not previously uploaded}, abstract = {The past two decades have seen increasing sophistication in software work. Now and in the future, the work of both practitioners and researchers would be helped by a more objective and finer granularity recognition of types of software evolution and software maintenance activities as actually done. To these ends, this paper proposes a clarifying redefinition of the types of software evolution and software maintenance. The paper bases the proposed classification not on people's intentions but upon objective evidence of maintainers' activities ascertainable from observation of activities and artifacts, and/or a before and after comparison of the software documentation. The classification includes taking into account in a semi-hierarchical manner evidence of the change or lack thereof in: (1) the software, (2) the documentation, (3) the properties of the software, and (4) the customer-experienced functionality. A comparison is made with other classifications and typologies. The paper provides a classified list of maintenance activities and a condensed decision tree as a summary guide to the proposed evidence-based classification of the types of software evolution and software maintenance.}, biburl = {http://www.bibsonomy.org/bibtex/290e3c09f10e3b5ec06f3d79658cce415/neilernst}, keywords = {taxonomy software evolution} } @book{brooks75, title = {The mythical man-month}, address = {Reading, Mass. u.a.}, author = {Frederick Phillips Brooks}, publisher = {Addison-Wesley}, year = 1975, isbn = {0-201-00650-2}, biburl = {http://www.bibsonomy.org/bibtex/23b4ebe26f9f306d3bd619612f857ef14/neilernst}, keywords = {software seminal} } @article{pikkarainen08ese, title = {The impact of agile practices on communication in software development}, author = {M. Pikkarainen and J. Haikara and O. Salo and P. Abrahamsson and J. Still}, editor = {Tore Dybå}, journal = {Empirical Software Engineering}, year = 2008, url = {http://dx.doi.org/10.1007/s10664-008-9065-9}, abstract = {Agile software development practices such as eXtreme Programming (XP) and SCRUM have increasingly been adopted to respond to the challenges of volatile business environments, where the markets and technologies evolve rapidly and present the unexpected.In spite of the encouraging results so far, little is known about how agile practices affect communication. This article presents the results from a study which examined the impact of XP and SCRUM practices on communication within software development teams and within the focal organization. The research was carried out as a case study in F-Secure where two agile software development projects were compared from the communication perspective. The goal of the study is to increase the understanding of communication in the context of agile software development: internally among the developers and project leaders and in the interface between the development team and stakeholders (i.e. customers, testers, other development teams). The study shows that agile practices improve both informal and formal communication. However, it further indicates that, in larger development situations involving multiple external stakeholders, a mismatch of adequate communication mechanisms can sometimes even hinder the communication. The study highlights the fact that hurdles and improvements in the communication process can both affect the feature requirements and task subtask dependencies as described in coordination theory. While the use of SCRUM and some XP practices facilitate team and organizational communication of the dependencies between product features and working tasks,the use of agile practices requires that the team and organization use also additional plan-driven practices to ensure the efficiency of external communication between all the actors of software development.}, biburl = {http://www.bibsonomy.org/bibtex/251b0ef8b8fa0269a593e586063d5048f/neilernst}, keywords = {should-read software agile empirical} } @inproceedings{ernst07icsm, title = {Tracing software evolution history with design goals}, address = {Paris, France}, author = {Neil A. Ernst and John Mylopoulos}, booktitle = {International Workshop on Software Evolvability at ICSM}, month = {October}, publisher = {IEEE Computer Society}, year = 2007, url = {http://www.neilernst.net/blog/wp-content/uploads/2007/08/swhist.pdf}, abstract = {When designing software for evolvability, it is important to understand which particular designs have worked in the past – and which have not. This paper argues that understanding the history of a software innovation is valuable in setting the context for future innovations. There is no formal discipline of software history. While there is an active body of research in information technology (IT) and innovation management, which seeks to understand how to maximize value from IT spending, this research often ignores the meaningful technological underpinnings of such tools. We suggest that the study of design history should be extended to software artifacts. The paper introduces notions like requirements analysis, technology context, and social context to explain how, and why, certain technologies evolved as they did. We apply these concepts to the history of distributed computing protocols. We conclude with observations drawn from this history that suggest designing software for evolvability must consider the history of similar applications in the requirements analysis.}, biburl = {http://www.bibsonomy.org/bibtex/23b8ed0b0f57e2af912a9bb84518d0d6c/neilernst}, keywords = {software goals personal requirements history design} } @inproceedings{berry05refsq, title = {The Four Levels of Requirements Engineering for and in Dynamic Adaptive Systems}, address = {Porto, Portugal}, author = {Daniel M. Berry and Betty H.C. Cheng and Ji Zhang}, booktitle = {International Workshop on Requirements Engineering: Foundation for Software Quality}, month = {June}, year = 2005, url = {http://www.cse.msu.edu/~zhangji9/publications/Berry05Four.pdf}, biburl = {http://www.bibsonomy.org/bibtex/2d5881b40414277617e9bf3a909b36252/neilernst}, keywords = {software dynamic adaptive} } @article{hannay08tose, title = {The Role of Deliberate Artificial Design Elements in Software Engineering Experiments}, author = {Jo Hannay and Magne Jørgensen}, journal = {IEEE Transactions on Software Engineering}, month = {March/April}, number = 2, pages = {242-259}, volume = 34, year = 2008, url = {http://dx.doi.org/10.1109/TSE.2008.13}, abstract = {Increased realism in software engineering experiments is often promoted as an important means to increase generalizability and industrial relevance. In this context, artificiality, e.g., the use of constructed tasks in place of realistic tasks, is seen as a threat. In this article, we examine the opposite view, that deliberately introduced artificial design elements may increase knowledge gain and enhance both generalizability and relevance. In the first part of the article, we identify and evaluate arguments and examples in favor of, and against, deliberately introducing artificiality into software engineering experiments. In the second part of the article, we summarize a content analysis of articles reporting software engineering experiments published over the ten-year period 1993-2002. The analysis reveals a striving for realism and external validity, but little awareness of for what and when, various degrees of artificiality and realism are appropriate. We conclude that an increased awareness and deliberation in these respects is essential. However, arguments in favor of artificial design elements should not be used to justify studies that are badly designed or that have research questions of low relevance.}, biburl = {http://www.bibsonomy.org/bibtex/20dc83b000a90b34f14dc2800e754d88b/neilernst}, keywords = {empirical software} } @book{easterbrook07empirical, title = {Selecting Empirical Methods for Software Engineering Research}, author = {Steve Easterbrook and Janice Singer and Margaret-Anne Storey and Daniela Damian}, booktitle = {Guide to Advanced Empirical Software Engineering}, editor = {F. Shull and J. Singer}, publisher = {Springer}, year = 2007, abstract = {Selecting a research method for empirical software engineering research is problematic because the benefits and challenges to using each method are not yet well catalogued. Therefore, this chapter describes a number of empirical methods available. It examines the goals of each and analyzes the types of questions each best addresses. Theoretical stances behind the methods, practical considerations in the application of the methods and data collection are also briefly reviewed. Taken together, this information provides a suitable basis for both understanding and selecting from the variety of methods applicable to empirical software engineering.}, biburl = {http://www.bibsonomy.org/bibtex/2a029b7aa2273424b4606723f672d4da6/neilernst}, keywords = {empirical research methods software} } @inproceedings{sneed07modse, title = {The Drawbacks of Model-Driven Software Evolution}, address = {Amsterdam}, author = {Harry Sneed}, booktitle = {Workshop on Model-Driven Software Evolution at CSMR}, month = {March}, year = 2007, url = {http://www.sciences.univ-nantes.fr/MoDSE2007/p9.pdf}, abstract = {This short paper is an essay on the drawbacks of model driven software evolution which apply equally well to model driven software development. The idea of automatically generating code changes from a UML type model is equally enticing as that of automatically generating whole components from such a model. The drawback is that there is then nothing to test against, since there is only one description of the system, the model. This violates the principles of software verification and validation, according to which correctness can only be demonstrated by comparing two independent descriptions of the same solution. For this reason, the author proposes another interpretation of model driven evolution, one in which the requirements model serves as a basis for propagating changes to both the code and the test, along two independent paths. The UML type system design could then be generated from the code and not [vice] versa}, biburl = {http://www.bibsonomy.org/bibtex/20194bcfa92f21ac8ea1a6eae482d5cb2/neilernst}, keywords = {evolution Software model} } @article{hoorn07, title = {Requirements change: Fears dictate the must haves; desires the won't haves}, author = {Johan F. Hoorn and Elly A. Konijn and Hans van Vliet and Gerrit van der Veer}, booktitle = {Selected papers from the 1st International Workshop on Requirements Engineering for Business Need and IT Alignment (REBNITA'05), 1st International Workshop on Requirements Engineering for Business Need and IT Alignment}, journal = {Journal of Systems and Software}, month = {#mar#}, number = 3, pages = {328--355}, volume = 80, year = 2007, url = {http://www.sciencedirect.com/science/article/B6V0N-4K71638-1/2/650a0f72639b8b73407464b7e470c91c}, abstract = {We attempt to contribute to a general theory of requirements change from a goal-oriented and viewpoints-driven angle. To practitioners, this knowledge is relevant to anticipate changes in certain types of requirements, which may shorten the project's timeline, reduce costs, and increase product quality. Initially, we followed the common assumptions that what should be on a system is demanded by goals to achieve and what should not be on a system is demanded by goal states to avoid. However, requirements engineering of a diversity of systems (capacity and warehouse management, COTS PCs, and a Braille mouse) revealed that must requirements are predicted by goals to avoid (!) and won't requirements by goals to approach (!). Expectations about the positive or negative impact (valence) of requirements on goals played a moderating role. We unfold the gradual discovery of this "goals-to-requirements chiasm" (CHI-effect or [chi]-effect), claiming that variability in agreement to positive or negative requirements is predicted by goals of opposite polarity. We found that whether the [chi]-effect occurred or not, depended on the alignment of stakeholder viewpoints on goals and requirements. Comments from practitioners are included.}, biburl = {http://www.bibsonomy.org/bibtex/22796b941aecba62f3f86013eb3d37b23/neilernst}, keywords = {Requirements Goal-driven Viewpoints RE Empirical validation software questionnaires change engineering Structured} } @article{kadir04, title = {Relating evolving business rules to software design}, author = {W. M. N. Wan-Kadir and Pericles Loucopoulos}, journal = {Journal of Systems Architecture}, month = {#jul#}, note = {Adaptable System/Software Architectures}, number = 7, pages = {367--382}, volume = 50, year = 2004, url = {http://www.sciencedirect.com/science/article/B6V1F-4B3MV6W-3/2/d6210685d0d23b70e28c9c4ea48c3dcf}, abstract = {In order to remain useful, it is important for software to evolve according to the changes in its business environment. Business rules, which can be used to represent both user requirements and conditions to which the system should conform, are considered as the most volatile part in today's software applications. Their changes bring high impact on both the business processes and the software itself. In this paper, we present an approach that considers business rules as an integral part of a software system and its evolution. The approach transcends the areas of requirements specification and software design. We develop the Business Rule Model to capture and specify business rules, and the Link Model to relate business rules to the metamodel level of software design elements. The aim is to improve requirements traceability in software design, as well as minimizing the efforts of software changes due to the changes of business rules. The approach is demonstrated using examples from an industrial application.}, biburl = {http://www.bibsonomy.org/bibtex/2016a71c6014bd36e5d0c1e648350600f/neilernst}, keywords = {requirements User rules Business Software evolution architecture/design} } @inproceedings{royce87, title = {Managing the development of large software systems: concepts and techniques}, address = {Monterey, CA, USA}, author = {W. W. Royce}, booktitle = {International Conference on Software Engineering}, pages = {328--338}, publisher = {IEEE Computer Society Press}, year = 1987, url = {http://portal.acm.org/citation.cfm?id=41801}, location = {Monterey, California, United States}, isbn = {0-89791-216-0}, description = {Originally published in 1970. Describes waterfall model with iteration.}, biburl = {http://www.bibsonomy.org/bibtex/212d7128ee85d39516a39e10a11b83a2f/neilernst}, keywords = {methodology waterfall software} } @article{brooks87, title = {No {S}ilver {B}ullet: {E}ssence and {A}ccidents of {S}oftware {E}ngineering}, author = {Frederick P. Brooks}, journal = {IEEE Computer}, month = {April}, number = 4, pages = {10--19}, volume = 20, year = 1987, url = {http://info.computer.org/portal/site/computer/index.jsp?pageID=computer_level1&path=computer/homepage/misc/Brooks&file=index.xml&xsl=article.xsl}, id = {111765}, priority = {3}, biburl = {http://www.bibsonomy.org/bibtex/2360b0bf445fa15e647edf610608ade72/neilernst}, keywords = {seminal engineering software} } @article{chmura90, title = {Evaluating software design processes by analyzing change data overtime}, author = {L.J. Chmura and A.F. Norcio and T.J. Wicinski}, journal = {Transactions on Software Engineering}, pages = {729-740}, volume = 16, year = 1990, url = {http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=56099}, issn = {0098-5589}, doi = {10.1109/32.56099}, abstract = {An analysis is presented of early design and code change data from the software cost reduction (SCR) project, a well-reported effort conducted at the US Naval Research Laboratory from 1978 to 1988. The analyses are mostly time-based studies of the change data and relationships between the data and SCR personnel activity data. Some analyses of the change data show patterns consistent with a major goal of the SCR project: the design and development of easy-to-change software. Specifically, most changes took a day or less to uncover and resolve; the majority of changes updated at most one module. Moreover, these percentages remained fairly stable. No positive relationship appeared between error-correction effort and the number of days that an error remained in the SCR design documentation. Other analyses suggest that consistency may have been temporary. For example, the analyses suggest a stepwise growth in average change effort, and an increasing percentage of changes resulted in module interface updates. Certain specific ratios between SCR change data and personnel activity data may be possible indicators of design incompleteness}, biburl = {http://www.bibsonomy.org/bibtex/2246d2273b6182382a4e2399b7cff5b45/neilernst}, keywords = {requirements SCR seminal software} } @techreport{mcgarry_software_1994, title = {Software Process Improvement in the NASA Software Engineering Laboratory}, address = {Pittsburgh, PA, USA}, author = {Frank McGarry and Rose Pajerski and Gerald Page and Sharon Waligora and Victor Basili and Martin Zelkowitz}, institution = {Software Engineering Institute}, month = {December}, number = {CMU/SEI-94-TR-22}, year = 1994, url = {http://citeseer.ist.psu.edu/mcgarry94software.html}, description = {zotero}, abstract = {The Software Engineering Laboratory (SEL) was established in 1976 for the purpose of studying and measuring software processes with the intent of identifying improvements that could be applied to the production of ground support software within the Flight Dynamics Division (FDD) at the National Aeronautics and Space Administration (NASA)/Goddard Space Flight Center (GSFC). The SEL has three member organizations: NASA/GSFC, the University of Maryland, and Computer Sciences Corporation (CSC). The concept of process improvement within the SEL focuses on the continual understanding of both process and product as well as goal-driven experimentation and analysis of process change within a production environment.}, biburl = {http://www.bibsonomy.org/bibtex/206fbdd14fe2ab1436ee10edc17fd595d/neilernst}, keywords = {process software} } @article{basili84, title = {Software Errors and Complexity: An Empirical Investigation.}, author = {Victor R. Basili and Barry T. Perricone}, journal = {Commun. ACM}, number = 1, pages = {42-52}, volume = 27, year = 1984, url = {http://portal.acm.org/citation.cfm?id=2085}, description = {dblp}, biburl = {http://www.bibsonomy.org/bibtex/22dc15c7416ad9dcde10ea1e949787c90/neilernst}, keywords = {empirical could-read software complexity} } @article{parnas85, title = {Software Aspects of Strategic Defense Systems.}, author = {David Lorge Parnas}, journal = {Commun. ACM}, number = 12, pages = {1326-1335}, volume = 28, year = 1985, url = {http://klabs.org/richcontent/software_content/papers/parnas_acm_85.pdf}, date = {2003-11-20}, description = {dblp}, biburl = {http://www.bibsonomy.org/bibtex/25f3fc2515da91c29e647dcbd5078bd42/neilernst}, keywords = {complexity software} } @inproceedings{grundy07, title = {Supporting Generic Sketching-Based Input of Diagrams in a Domain-Specific Visual Language Meta-Tool}, address = {Minneapolis, Minnesota}, author = {John Grundy and John Hosking}, booktitle = {International Conference on Software Engineering}, month = {May}, pages = {282-291}, year = 2007, url = {http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4222590}, issn = {0270-5257}, isbn = {0-7695-2828-7}, doi = {10.1109/ICSE.2007.81}, abstract = {Software engineers often use hand-drawn diagrams as preliminary design artefacts and as annotations during reviews. We describe the addition of sketching support to a domain-specific visual language meta-tool enabling a wide range of diagram-based design tools to leverage this human-centric interaction support. Our approach allows visual design tools generated from high-level specifications to incorporate a range of sketching-based functionality including both eager and lazy recognition, moving from sketch to formalized content and back, and using sketches for secondary annotation and collaborative design review. We illustrate the use of our sketching extension for an example domain-specific visual design tool and describe the architecture and implementation of the extension as a plug-in for our Eclipse-based meta-tool.}, biburl = {http://www.bibsonomy.org/bibtex/214cc3e4a3c741a7591a7bb2836620b53/neilernst}, keywords = {uml software sketching} } @article{girba06, title = {Modeling history to analyze software evolution}, author = {Tudor Gîrba and Stéphane Ducasse}, journal = {Journal of Software Maintenance and Evolution: Research and Practice}, number = 3, pages = {207-236}, volume = 18, year = 2006, url = {http://dx.doi.org/10.1002/smr.325}, ee = {http://dx.doi.org/10.1002/smr.325}, date = {2007-01-11}, description = {Presents a meta-model of software evolution, little focus on requirements}, abstract = {The histories of software systems hold useful information when reasoning about the systems at hand or when reasoning about general laws of software evolution. Over the past 30 years, research has been increasingly spent on understanding software evolution. However, the approaches developed so far do not rely on an explicit meta-model and, thus, they make it difficult to reuse or compare their results. We argue that there is a need for an explicit meta-model for software evolution analysis. We present a survey of the evolution analyses and deduce a set of requirements that an evolution meta-model should have. We define Hismo, a meta-model in which history is modeled as an explicit entity. Hismo adds a time layer on top of structural information, and provides a common infrastructure for expressing and combining evolution analyses and structural analyses. We validate the usefulness of our meta-model by presenting how different analyses are expressed on it.}, biburl = {http://www.bibsonomy.org/bibtex/2737aeaee273faae15b9029dcfd0ea790/neilernst}, keywords = {evolution software modeling visualization} }