Search

More than two decades ago, researchers started to mine the data stored in software repositories to help software developers in making informed decisions for developing and testing software systems. Bug prediction was one of the most promising and popular research directions that uses the data stored in software repositories to predict the bug-proneness or number of bugs in source files. On that topic and as part of Emanuel's PhD studies, we submitted a paper with the title Comparing fine-grained source code changes and code churn for bug prediction [8] to the 8th Working Conference on Mining Software Engineering, held 2011 in beautiful Honolulu, Hawaii. Ten years later, it got selected as one of the finalists to receive the MSR 2021 Most Influential Paper Award. In the following, we provide a retrospective on our work, describing the road to publishing this paper, its impact in the field of bug prediction, and the road ahead.

International audience; The 2018 2nd International Workshop on Context-aware, Autonomous and Smart Architectures (CASA 2018) was held in conjunction with the 12th European Conference on Software Architecture (ECSA 2018), on September, 24th, 2018 in Madrid, Spain. The main topic of the workshop concerned the design of software architectures for dynamic, autonomous, and adaptive context-aware smart systems. Such systems address changes and cope with uncertainties at runtime. Therefore, the software architecture of such system should ensure the basis for their dynamicity, adaptivity, and autonomy. These basis should be solid because they represent the backbone of a system, and in the same time flexible because they address dynamicity during execution. The one-day workshop aimed to bring together researchers and practitioners from the academic and the industrial world to share and discuss their approaches, solutions, methodologies, ideas, and open questions about the software architecture design for context-aware, autonomous, and smart systems. The workshop enabled discussions and put the basis for future collaborations among the participants.

The rapid pace with which software needs to be built, together with the increasing need to evaluate changes for end users both quantitatively and qualitatively calls for novel software engineering approaches that focus on short release cycles, continuous deployment and delivery, experiment-driven feature development, feedback from users, and rapid tool-assisted feedback to developers. To realize these approaches there is a need for research and innovation with respect to automation and tooling, and furthermore for research into the organizational changes that support flexible data-driven decision-making in the development lifecycle. Most importantly, deep synergies are needed between software engineers, managers, and data scientists. This paper reports on the results of the joint 5th International Workshop on Rapid Continuous Software Engineering (RCoSE 2019) and the 1st International Workshop on Data-Driven Decisions, Experimentation and Evolution (DDrEE 2019), which focuses on the challenges and potential solutions in the area of continuous data-driven software engineering.

Quantum computing, and to an even greater extent quantum technology, is changing the world. Quantum computing is not an evolution of classical computer science; it is actually a revolution that completely changes the computing paradigm. Quantum computers are based on the principles of quantum mechanics, such as superposition and entanglement, and they seek to boost computational power exponentially. Many problems that have until now been impossible to solve, in practical terms, might very well be able to be addressed by means of quantum computing. The fact is that at the present time quantum computing is influencing most business sectors and research fields, due to its various promising applications. To make such applications become reality, quantum algorithms must be specially coded for these extremely different computers. Although some well-known quantum algorithms already exist, the need for quantum software will increase dramatically in the next years. In that context, quantum software has to be produced in a more industrial and controlled way, i.e., aspects such as quality, delivery, project management, or evolution of quantum software must be addressed. We are sure that quantum computing will be the main driver for a new software engineering golden age during the present decade of the 2020s.

Java Path nder (JPF) was originally developed as an explicit- state software model checker, and subsequently evolved into an extensible Java bytecode analysis framework that has been suc- cessfully used to implement techniques such as symbolic and con- colic execution, compositional veri cation, parallel execution, in- cremental program analysis, and many more. To share recent research progress with JPF and related tools among the community, we have organized the annual JPF work- shop with the Automated Software Engineering Conference (ASE) 2019, held in San Diego, California, USA. We invited submissions about on-going and existing research, experience, and position papers on topics (1) related to JPF, its extensions and applica- tions in various domains; and (2) Java/Android program analysis in general. This paper gives an overview of all presentations and papers of the workshop, as well the results of the discussions.

New trends in software engineering recently emerged to cope with even more complex systems which in turns highlight problems software shortfalls and defects. The SQUADE (Software QUAlities and their DEpendencies) workshop focuses on increasing the understanding of the nature of Software Qualities (SQs), i.e., nonfunctional properties or extra-functional requirements (e.g., reliability, security, maintainability, etc.), and their interrelationships with the aim of bringing them into practice of software engineering. The topic is highly relevant due to the current trend of designing and developing software-intensive systems with larger complexity, increased autonomy, higher speed of changes, and growing need for interoperability within systems of systems. Unfortunately, this new trend comes with more software shortfalls and defects, which are widely and publicly spread. The primary goal of the workshop is to bring together researchers and practitioners to build more solid foundations when dealing with software qualities.

Smart Cyber-Physical Systems (sCPS) are a novel kind of Cyber- Physical System engineered to take advantage of large-scale cooperation between devices, users and environment to achieve added value in the face of uncertainty and changing environments. Examples of sCPS include modern traffic systems, Industry 4.0 systems, systems for smart buildings, and smart energy grids. The uniting aspect of all these systems is that to achieve their high level of intelligence, adaptivity and ability to optimize and learn, they rely heavily on software. This makes them software-intensive systems, where software becomes their most complex part. Engineering sCPS thus becomes a recognized software engineering discipline, which, due to specifics of sCPS, can only partially rely on the existing body of knowledge in software engineering. In fact, it turns out that many of the traditional approaches to architecture modeling and software development fall short in their ability to cope with the high dynamicity and uncertainty of sCPS. This calls for innovative approaches that jointly reflect and address the specifics of such systems. This paper maps the discussions and results of the Fourth International Workshop on Software Engineering for Smart Cyber-Physical Systems (SEsCPS 2018), which focuses on challenges and promising solutions in the area of software engineering for sCPS.

Programming editors have evolved over the years. However, we still lack an environment that can allow on-the-fly collaboration between multiple programmers. We envision Incide, an integrated development environment that allows a synergistic collaboration environment by using program synthesis technology to combine partial solutions from multiple programmers attempting to solve the (same) problem into one concrete solution. This solution is then communicated to the editor of each programmer as patches along with personalization on syntactic elements like choice of programming language constructs and variable names. We believe that such editors will improve productivity on complex solutions by bringing a discipline into combining the intuition and intellect of multiple programmers.

The 2017 1st International Workshop on Context-aware, Autonomous and Smart Architectures (CASA 2017) was held in conjunction with the 11th European Conference on Software Architecture (ECSA 2017), on September, 12th, 2017 in Canterbury, United Kingdom. The goal of this one -day workshop was to bring together researchers and practitioners from academic environment and from the industry to share their solutions, ideas, visions, and doubts in the design of software architectures for context-aware, autonomous, and smart solutions. The workshop focused on architectural aspects offering a complementary vision of such solutions with respect to the available application- and user-oriented perspectives on context-awareness, autonomy, and smartness. Furthermore, the workshop aimed to enable discussions, partnerships, and collaborations among the software engineers interested in these solutions.

Free/libre and open source software (FLOSS) originated from "hacker culture" and struggled against software privatization. The idea is that anyone is freely licensed to use, copy, study, and change the software in any way, and the source code is openly shared so that people are encouraged to voluntarily improve the design of the software. This is in contrast to proprietary software, where the software is under restrictive copyright licensing and the source code is usually hidden from the users. To give the users such freedom and control in their use of software, Richard Stallman launched the GNU project (Stallman, 1983), together with a manifesto stating that everyone will be permitted to modify and redistribute GNU.

As software becomes more important and ubiquitous, high quality software also becomes crucial. We depend on software developers who write the software to also maintain and improve its quality. When developers make changes to software, they rely on continuous integration [6] and regression testing [15] to check that changes do not break existing functionality. Continuous integration (CI) automates the process of building and testing software after every change. The process of running tests on the code after every change is known as regression testing. The goal of regression testing is to allow developers to detect and fix faults early on, ideally the moment the faults are introduced. Regression testing is widely used in both industry and open source, but regression testing suffers from two main challenges: (1) regression testing is costly, and (2) regression test suites often contain flaky tests.

All experimental studies are prone to risk with regard to the validity of their results. After applying a determined action to control a threat, during planning or executing an experiment, new risks to the study validity can arise. Aim. To improve the quality of controlled experiments in Software Engineering (SE), setting out strategies that permit researchers giving priority to specific threats in causes virtue and consequences (trade-offs), which exist between threats to validity and possible measures for control. Method. We will employ a knowledge base acquired through a survey and a Systematic Literature Review to model an approach for prioritizing and controlling threats to validity. The proposed approach will also be evaluated through experiments. Contribution. To improve the control processes for threats to validity considered to be critical, reducing efforts required by researchers, thereby improving the quality of future controlled experiments in the Software Engineering area by increasing its results? validity.

Every other personal computer today is provided with a coprocessor making it a heterogeneous computing environment. As the heterogeneous and high-performance computing (HPC) infrastructure becomes a commodity, the need to improve software development productivity to build efficient parallel programs for this infrastructure becomes all the more crucial. While the mainstream software development methodology focuses on modular design, reusability, ease of understanding and so on, parallel program development emphasizes on performance, optimal use of a hardware resource, scalability, execution correctness, and portability across multiple hardware platforms. In this paper, we identify a few unique software development productivity requirements for heterogeneous systems. These requirements are concerned with design abstraction, reusability, and design verification. While these requirements are applicable for a conventional software as well, their implications are far reaching in the context of parallel programs. Here we discuss significant e orts in building tools and frameworks to i) provide powerful abstraction over the hardware, ii) build software libraries for parallel hardware access and iii) implement verification mechanisms to check the correctness of a program behavior in a heterogeneous runtime environment. We also identify several important gaps in the existing work that needs to be addressed in order to make the current body of work useful in practice.

The International Workshop on Realizing Arti cial Intelligence Synergies in Software Engineering (RAISE) aims to present the state of the art in the crossover between Software Engineering and Arti cial Intelligence. This workshop explored not only the appli- cation of AI techniques to SE problems but also the application of SE techniques to AI problems. Software has become critical for realizing functions central to our society. For example, software is essential for nancial and transport systems, energy generation and distribution systems, and safety-critical medical applications. Software development costs trillions of dollars each year yet, still, many of our software engineering methods remain mostly man- ual. If we can improve software production by smarter AI-based methods, even by small margins, then this would improve a crit- ical component of the international infrastructure, while freeing up tens of billions of dollars for other tasks.

Bibliometric analysis is a commonly used technique to analyze scholarly publications to extract useful insights about research and scientific papers which can then be used for decision making by policy makers and administrators. Bibliometric analysis helps in understanding various aspects of scientific knowledge creation and dissemination such as author and institute productivity, impact of articles in terms of citations, university and industry collaboration, geographical contributions and ethnic and gender minority in authorship. ACM SIGSOFT Software Engineering Notes (SEN) is a non-refereed but a reputed and edited publication for informal writings and reports about Software Engineering (SE). ACM SIGSOFT SEN publishes various types of submissions such as paper, report, column, announcement and book review. These submissions are published in the ACM Digital Library (DL). We conduct a bibliometric analysis of articles published in ACM SIGSOFT SEN during a ten year period from 2007 to 2016. Our objective is to provide a historical overview (one decade) of ACM SIGSOFT SEN and reflect on the past so that the ACM SIGSOFT community and contributors can assess the strengths and shortcomings of the SEN. We believe that the bibliometric analysis presented in this paper can provide insights on the extent to which the SEN is meeting its desired objectives.

Lua is a programming language designed as scripting language, which is fast, lightweight, and suitable for embedded applications. Due to its features, Lua is widely used in the development of games and interactive applications for digital TV. However, during the development phase of such applications, some errors may be introduced, such as deadlock, arithmetic overflow, and division by zero. This paper describes a novel verification approach for software written in Lua, using as backend the Efficient SMTBased Context-Bounded Model Checker (ESBMC). Such an approach, called bounded model checking - Lua (BMCLua), consists in translating Lua programs into ANSI-C source code, which is then verified with ESBMC. Experimental results show that the proposed verification methodology is effective and efficient, when verifying safety properties in Lua programs. The performed experiments have shown that BMCLua produces an ANSI-C code that is more efficient for verification, when compared with other existing approaches. To the best of our knowledge, this work is the first that applies bounded model checking to the verification of Lua programs.

Writing specifications about program behavior is hard. Writing specifications about non-functional effects such as resource usage is often even harder. If manually instrumenting the program is not an option, programmers have to rely on comment-based specification languages like JML to introduce ghost variables and other fairly abstract concepts that are complicated and hard to maintain. Even worse, most static analysis tools nowadays operate on bit- or bytecode and cannot process those type of specifications To address this problem, we propose a library-based specification formalism for time complexity in Java. The approach is inspired by the success of assertion libraries like CodeContracts and Guava. Our library provides a set of methods and enumerated types that allow the user to write complexity assertions in a 'human' readable form and without instrumenting the code. On the backend, we provide a bytecode rewriting tool that uses these assertions to automatically instrument the program with counter variables. The transformed program can then be checked via testing or off-the-shelf automated static analyzers

In this paper, we present a framework for exhaustive test input generation and execution of tests for websites using JPF, and Java libraries such as Selenium and JUnit. Specifically, we utilize the core functionality of jpf-nhandler, a JPF extension, to enable use of useful Java libraries such as GSON in the JPF environment. The paper further describes iterating through webpages successively and generating test inputs systematically for each page. It also presents the experimental results of running our framework on a small example website and a real-world website

Errors in con gurations, rather than source code, have become one of the major causes of system failures, resulting in security vulnerabilities, application outages, and incorrect program execu- tions. We report on the structure and results of the rst Interna- tional Workshop on Software Engineering for Infrastructure and Con guration Code. Our aim in organizing this jworkshop was to

Analyzing, implementing and maintaining security requirements of software-intensive systems and achieving truly secure software requires planning for security from ground up, and continuously assuring that security is maintained across the software's lifecycle and even after deployment when software evolves. Given the increasing complexity of software systems, new application domains, dynamic and often critical operating conditions, the distributed nature of many software systems, and fast moving markets which put pressure on software vendors, building secure systems from ground up becomes even more challenging. Security-related issues have previously been targeted in software engineering sub-communities and venues. In the second edition of the International Workshop on Security from Design to Deployment (SEAD) at the International Conference on Automated Software Engineering (ASE) 2020, we aimed to bring the research and practitioner communities of requirements engineers, security experts, architects, developers, and testers together to identify foundations, and challenges, and to formulate solutions related to automating the analysis, design, implementation, testing, and maintenance of secure software systems.

The International Conference on Software and Systems Process (ICSSP), continuing the success of Software Process Workshop (SPW), the Software Process Modeling and Simulation Workshop (ProSim) and the International Conference on Software Process (ICSP) conference series, has become the established premier event in the field of software and systems engineering processes. It provides a leading forum for the exchange of research outcomes and industrial best-practices in process development from software and systems disciplines. ICSSP 2016 was held in Austin, Texas, from 14-15 May 2016, co-located with the 38th International Conference on Software Engineering (ICSE). The theme of mICSSP 2016 was studying \Process(es) in Action" by recognizing that the AS-Planned and AS-Practiced processes can be quite different in many ways including their ows, their complexity and the evolving needs of stakeholders. Papers presented at ICSSP discussed this issue addressing different domains, providing concepts, evidence, and experiences.

Many of today's software systems accommodate different usage and deployment scenarios. Intentional and unintentional variability in functionality or quality attributes (e.g., performance) of software significantly increases the complexity of the problem and design space of those systems. The complexity caused by variability becomes increasingly difficult to handle due to the increasing size of software systems, new and emerging application domains, dynamic operating conditions under which software systems have to operate, fast moving and highly competitive markets, and more powerful and versatile hardware. This paper reports results of the first International Workshop on Variability and Complexity in Software Design that brought together researchers and engineers interested in the topic of complexity and variability. It also outlines directions the field might move in the future

With the proliferation of the Internet of Things and the associ- ated trend of integration of software with "things", it is predicted that the complexity of the systems-of-future will be characterized not only by scale and variety of devices and software but also by the constant change of the system context due to the mobil- ity of devices and M2M interactions. Consequently, the current paradigm of automation will be inadequate for the management and operation of these systems. The dominant approach to ad- dress this issue is to design and develop autonomous systems that can adapt to the changes in various levels and keep delivering the expected functionality. Such systems need fundamentally different architectures, components and methodologies incorporating new paradigms such as machine learning and intelligent decision making. In this workshop, we attempt to discuss the in uence of these paradigms on the development life cycle of adaptive soft- ware, starting from requirements, design and architecture and also their verification and validation.

There are seemingly many advantages to being able to identify, document, test, and trace single or "atomic" requirements. Why then has there been little attention to the topic and no widely used definition or process on how to define atomic requirements? Definitions of requirements and standards focus on user needs, system capabilities or functions; some definitions include making individual requirements singular or without the use of conjunctions. In a few cases there has been a description of atomic system events or requirements. This work is surveyed here although there is no well accepted and used best practice for generating atomic requirements. Due to their importance in software engineering, quality and metrics for requirements have received considerable attention. In the seminal paper on software requirements quality, Davis et al. proposed specific metrics including the "unambiguous quality factor" and the "verifiable quality factor"; these and other metrics work best with a clearly enumerable list of single requirements. Atomic requirements are defined here as a natural language statement that completely describes a single system function, feature, need, or capability, including all information, details, limits, and characteristics. A typical user login screen is used as an example of an atomic requirement which can include both functional and nonfunctional requirements. Individual atomic requirements are supported by a system glossary, references to applicable industry standards, mock ups of the user interface, etc. One way to identify such atomic requirements is from use case or system event analysis. This definition of atomic requirements is still a work in progress and offered to prompt discussion. Atomic requirements allow clear naming or numbering of requirements for traceability, change management, and importance ranking. Further, atomic requirements defined in this manner are suitable for rapid implementation approaches (implementing one requirement at a time), enable good test planning (testing can clearly indicate pass or fail of the whole requirement), and offer other management advantages in project control.

The dependency on the correct functioning of embedded systems is rapidly growing, mainly due to their wide range of applications, such as micro-grids, automotive device control (e.g., airbag control), health care, surveillance, mobile devices, and consumer electronics. Their structures are becoming more and more complex and now require multi-core processors with scalable shared memory, in order to meet increasing computational power demands. As a consequence, reliability of embedded (distributed) software becomes a key issue during system development, which must be carefully addressed and assured. Normally, state-of-the-art verification methodologies for embedded systems generate test vectors (with constraints) and use assertion-based verification and highlevel processor models, during simulation; however, other additional challenges have been raised: the need for meeting time and energy constraints, handling concurrent software, dealing with platform restrictions, evaluating implementation-structure choices, and supporting new software architectures and legacy designs (usually written in low-level languages). The present paper discusses challenges, problems, and recent advances to ensure correctness and timeliness regarding embedded systems. Reliability issues, in the development of micro-grids and cyber-physical systems, are then considered, as a prominent (bounded) model checking application.

Software product lines (SPL) have evolved from being a niche research topic to a well-established approach towards development of a family of software-intensive systems, promising better quality in shorter time and less cost. The hall of fame initiative of a 16 year running conference on SPL recognizes exemplary examples of successful application of SPL in practice. However, despite these advances, SPL are seen as quite effort intensive requiring huge initial investments and are not considered as mainstream software development. One of the primary reasons for this is the lack of standardized tools and methods to support development, maintenance and management of SPL. Specifically, every software product line is considered as a stand-alone project with custom tools and methods developed in most of the cases. This leads to a number of diversified, inconsistent and incompatible tools making it difficult to develop new tools or to choose from existing set of tools. It is here that the working group 4 (WG4) of the seventh subcommittee (SC7) titled "Software and Systems Engineering" of the Joint ISO/IEC Technical Committee (JTC1) of the International Organization for Standardization (ISO) and the International Electrotechnical Commission (IEC) has proposed a set of interrelated standards in the area of software and systems product lines (SSPL). In this report, we briefly outline the stateof-the-art in software product line tools and motivate the need for standardized tools and methods. We then provide an overview of SSPL standards based on our experience in the last several years. We finally conclude by inviting the entire software engineering community and practitioners to get involved in the critical analysis and creation of SSPLstandards and propel their use in both academia and industry.

The Unified Modeling Language (UML), with its 14 different diagram types, is the de-facto standard modeling language for object-oriented software modeling and documentation. Since the various UML diagrams describe different views of one, and only one, software system under development, they strongly depend on each other in many ways. In other words, the UML diagrams describing a software system must be consistent. Inconsistencies among these diagrams may be a source of faults during software development and analysis. It is therefore paramount that these inconsistencies be detected, analyzed and -- hopefully -- fixed. The goal of this workshop was to gather input and feedbacks on UML consistency rules from the community. This workshop provided an opportunity for researchers who have been working in the area of UML consistency to interact with each other at a highly interactive venue, improve the body of knowledge on UML consistency rules and discuss ideas for further research in this area. This report summarizes details of the workshop and the results obtained that day.

Efficient configuration management system is crucial for the success of any software product line (SPL). Due to ever changing needs of customers, SPL undergoes constant changes that are to be tracked in real time. In the context of customer-driven development, anticipation and change management are to be given paramount importance. It demands implementation of software variability that drives home changed, extended and customized configurations besides economy at scale. Moreover, the emergence of distributed technologies, the unprecedented growth of component based, serviceoriented systems throw ever increasing challenges to software product line configuration management. Derivation of a new product is a dynamic process in software product line that should consider functionality and quality attributes. Very few approaches are found on configuration management (CM) of SPL though CM is enough matured for traditional products. They are tailor made and inadequate to provide a general solution. Stated differently, a comprehensive approach for SPL configuration management and product derivation is still to be desired. In this paper, we proposed a framework that guides in doing so besides helping in SPL definitions in generic way. Our framework facilitates SPL configuration management and product derivation based on critical path analysis, weight computation and feedback. We proposed two algorithms namely Quality Driven Product Derivation (QDPD) and Composition Analysis algorithm for generating satisfied compositions and to find best possible composition respectively. The usage of weights and critical path analysis improves quality of product derivation. The framework is extensible and flexible thus it can be leveraged with variability-aware design patterns and ontology. We built a prototype that demonstrates the proof of concept. We tested our approach with Dr. School product line. The results reveal that the framework supports configuration management of SPL and derivation of high quality product in the product line. We evaluated results with ground truth to establish significance of our implementation

Submitted by PGCOMP UFBA (pgcomp@ufba.br) on 2016-06-17T14:54:02Z No. of bitstreams: 1 15-sen-alcemir.pdf: 947265 bytes, checksum: 89c8204bcf958cb2861d6e38d13be859 (MD5) Approved for entry into archive by Alda Lima da Silva (sivalda@ufba.br) on 2016-06-30T00:40:50Z (GMT) No. of bitstreams: 1 15-sen-alcemir.pdf: 947265 bytes, checksum: 89c8204bcf958cb2861d6e38d13be859 (MD5) Made available in DSpace on 2016-06-30T00:40:50Z (GMT). No. of bitstreams: 1 15-sen-alcemir.pdf: 947265 bytes, checksum: 89c8204bcf958cb2861d6e38d13be859 (MD5) Previous issue date: 2015-11 Two mechanisms widely used in the Software Product Lines (SPL) Engineering are the feature model and the conditional compilation. The former models the variability in the problem space and the latter realizes it in the solution space. Even though the research community know that the feature model imposes a number of constraints to the product line implementation, there is a lack of support to co-evolve problem space and solution space. In this paper, we present an exploratory study whether problem space constraints are considered at source code level of #ifdef-based SPL implementations. In order to accomplish our goal, we developed a preliminary approach to check problem and solution spaces in a prototype tool (fclcheck). The results show a lack of realization of feature model constraints while implementing variation points with that mechanism. We also evaluated the scalability of the approach and the recoverability of the tool. ACM SIGSOFT Software Engineering Notes

In software engineering there has traditionally been a distinction between high-level architecting and lower level implementation activities (e.g. coding and testing). Those who are developing and maintaining the software are often not engaged in early design activities. For example, software programmers tend to lack design and architecture skills and architects are often blamed for not knowing how to write good code and for not being involved in low-level implementation tasks. This results in software quality issues, software implementations that drifted from initial design, and incorrect or missing architectural decisions in the code. The continuous move towards reducing upfront architecture design efforts, and the popularity of practices such as test-driven development highlight the importance of enriching software implementation practices with new architecting notions, practices and tools. This was the topic of the First International Workshop on Bringing Architecture Design Thinking into Developers' Daily Activities. In this paper we summarize the workshop

Cloud Computing Design Patterns is written by Thomas Erl, Robert Cope, and Amin Naserpour, and published by Prentice Hall, © 2015, 978-0-13-385856-3, and is 591 pages long. The "Objective of This Book" section sets a lofty goal to catalog design patterns for cloud computing, targeting IT professionals who are involved in architecting, building, maintaining, evolving cloud-based solutions and environments. Since that fits squarely in the middle of my "day job", I was really excited to get my hands on this book.

SEGarage is a curated archive for software engineering tools developed through software engineering research. This service aims to ease the effort of finding and downloading tools from past research.

Effective and efficient testing with reduced costs and a high fault detection capability is the desirable goal in industry which can be achieved only through automation of all parts of the testing process. In the past decades, a great amount of research effort has been spent on automating all various parts of the testing process such as test case derivation, test selection, test oracle construction, test execution, and others. In addition, there has been a rapid growth in automated software testing tools which is stimulated in part through the shift towards agile development practices in industry that demands a high level of automation. Work on this topic has long been published as an important part of software engineering. In recent years, testing has been consistently among the top-most popular topics in submissions to software engineering conferences. The practice of software test automation (TA) has also moved forward significantly in the past few years. However, progress in TA is still required. Software systems have become more and more complicated through the integration of components developed by different vendors and using different techniques in different programming languages running on different platforms. The advent of cloud computing, mobile computing and the Internet of Things has imposed grave new challenges to TA. Those systems become increasingly reactive to changes in their environment, requiring equally adaptive TA approaches. Few software testing tools can currently handle the needed requirements to test such systems.

Security is a non-functional requirement difficult-to-handle during software development. However, it appears to be common in software engineering, that security is taken care of during the design- and test-phase only. If security is neglected during the implementation phase, flaws will be introduced. Those may be - if at all - found during testing where the cost-to-fix is higher as if found during the implementation phase. Hence, this research proposal suggests to investigate the extent to which code analysis tools can be used as a step towards continuous security inspection in software engineering projects. By automating security testing in development flaws can be found as soon as they are introduced. This could greatly reduce the cost to fix flaws and help building more secure software.

Replication is essential to build knowledge in empirical science. Experiment replications reported in the software engineering context present variabilities on their experiment elements, e.g., variables, materials. Further understanding these variabilities could help planning lack of strategy to support the representation of experiment variabilities and commonalities. In addition, there is also a gap related to effective reuse and traceability of experiment elements. These problems are likely to hamper the replication understanding and planning. In order to overcome these gaps, we intend to create a conceptual model and a tool to support replication planning. To develop these solutions, we will use concepts of experimentation and software product lines. Our idea is to build a core structure which allows the configuration of experiment elements based commonalities with previous replications and desired variabilities to fit the specific replication purposes. In this paper we describe related work, our research methodology, as well as the current research progress and expected future contributions.

Architects of complex software systems face the challenge of how best to assess the achievement of quality attributes and other key system drivers, how to reveal issues and risks early, and how to make decisions about architecture improvement. Software architecture quality has a large impact on this effort, but it is usually not assessed with quantitative measures. A software architecture metric quantifies architecture quality, value, and cost. While it is highly desirable to improve feedback between development and deployment through measurable means for intrinsic quality, value, and cost, efforts in software architecture quality measurement have lagged behind the body of work focusing on code quality. The goal of the Second International Workshop on Software Architecture and Metrics was to discuss progress on architecture and metrics, measurement, and analysis; to gather empirical evidence on the use and effectiveness of metrics; and to identify priorities for a research agenda.

This paper presents the practical experience and results of the Lion Project, which aimed to improve software development times at Heinsohn Business Technology (HBT), a large-scale Colombian software development company. The main result of this project is the LionWizard Framework, a set of libraries and tools with a focus on large-scale software reuse and integration. The Lion- Wizard Framework integrates all of the existing libraries at HBT using Maven and provides a Wizard. The latter uses code generation and program transformation to automatically integrate all of the required components into an initial codebase in Java EE. The Wizard provides sufficient exibility to seamlessly integrate future components into the development process. Before the Lion Project, software developers required several days of even weeks to integrate all of the required components into a code base for each project. This new framework reduces those times to a few hours.

User satisfaction is recognized as an important contributor to the success of software applications. It is subjective and influenced by several factors that are linked to the non-functional requirements. Although non-functional requirements provide good criteria for selection of web service in Service-Oriented Architecture, specifying them during the discovery process is a difficult task. Dealing with the non-functional requirements that have an inherent ability to conflict is a complex task and modeling them can facilitate analyzing them. The aim of our research work is to propose a framework to improve design stage during web service selection so as to produce minimal conflicts and dependencies between requirements. We argue that the design structure that best supports and embodies the user constraints is the one that best meets a user's needs. Our framework is proposed after a detailed study of the issues and challenges identified by published literature by researchers working on non-functional requirement To exemplify our work we consider a Remote Patient Monitoring System scenario and propose a complete framework that will take the user requirements as input and analyze how they interact using graph transformation rules. The output matrix of dependencies can help the designer to select the most desirable design solution. We make use of simple natural language processing techniques, graph transformation and the aspect oriented paradigm. By integrating the framework into the design phase, it is possible to limit the impact of changes and also to understand in advance the likely interdependencies. conflicts.

Software testing is an important phase of the software development life cycle. Testing is the process of executing the program with the goal of finding errors. The purpose of testing is not only to find the bugs in software but also to improve the quality of software. This paper compares traditional and object-oriented software testing. Today, object-oriented concepts are used throughout software engineering. Testing of object-oriented software is different from testing of traditional software. Object-oriented software testing offers new challenges to the software testing team, because the object-oriented approach supports several new and powerful features. This paper focuses on the need for adopting an object-oriented software-testing approach and the challenges that occur in object-oriented testing.

The DevOps movement intends to improve communication, collaboration, and integration between software developers (Dev) and IT operations professionals (Ops). Automation of software quality assurance is key to DevOps success. We present how automated performance benchmarks may be included into continuous integration. As an example, we report on regression benchmarks for application monitoring frameworks and illustrate the inclusion of automated benchmarks into continuous integration setups.

Architectural software patterns capture successful designs for recurring problems in software architecture. For the first time, a workshop in the tradition of the software-pattern conference series (e.g. PLoP, EuroPLoP) was held jointly with the European Conference on Software Architecture (ECSA 2014) in Vienna, Austria. The main objective of this workshop called MiniPLoP was to bring software architecture researchers closer to the pattern community and to introduce the writers' workshop format to them. Writers' workshop at PLoP conferences provide authors of pattern papers with high-density feedback given by peers within a limited timeframe. In addition, our workshop provided a forum to reect on the state of software architecture patterns and to discuss advances pattern research. This report contains an extended keynote abstract and summaries of the papers discussed during the workshop.

Recent studies indicate that multiple patches to software are found in a hefty portion of resolved bugs. It is also known that bugs that require multiple patches take longer to resolve, that their severity tends to be higher than the average and that they induce programmers to engage more in bug discussions. This work is concerned with the ability of programmers to predict a bug will be of this sort, and in particular that it may require future patches and greater refixing effort at the time the bug is fixed at the first time. A mathematical model is developed for a retrospective analysis of bugs maintenance history. In this model we compute the impact of an array of bug properties on the likelihood that a specific bug is chosen, among all open bugs, to receive its first fix. The studies we conduct on a sizable portion of the history of the Eclipse code base indicate that programmers tend to attend first to bugs which are easier to fix. The results further suggest that some of the criteria that programmers apply (probably unknowingly) to determine whether a bug is easy to fix, is the number of future patches it would require, and the amount of work involved in these patches. This is despite the fact that this information is not supposed to be available to the programmers at the time the first fix is made. It is anticipated that the method of analysis introduced in this work would have other applications in software engineering, but also outside of computer science.

A systematic approach in requirement engineering helps in discovering and understanding the requirements at different levels of abstraction as well as makes the requirements traceable and verifiable early in the project. This paper presents a methodology for requirement engineering by using a combination of formal and semiformal techniques to model software requirements for analysis and verification. The proposed framework incorporates requirement-analysis and requirement-verification models, which are guided by the Domain Model represented by a Conceptual Class diagram and the defined Ontology. The proposed approach is particularly useful when requirements are defined in hierarchical levels of abstraction and traceability between a requirement at a detailed level and its correspondence at an abstract level is required. The proposed framework also allows verification of the accordance of the requirements with respect to the Domain Model. The requirement analysis model at each level of abstraction is represented by a combination of three different modeling techniques: Conceptual Graph, Use-Case diagram and VDM-SL specification. A verification model to ensure traceability between the requirements at different abstraction levels, using a three-dimensional schema, is also proposed. The Requirements of an Intelligent Learning Management System are used as an example to illustrate the proposal.

The four GTSE (General Theory of Software Engineering) Workshops have brought awareness to, more or less mature, differing approaches, candidate theories for SE (Software Engineering). But one asks how to appraise the generality of these theories? And in case they are specialized sub-theories, are they amenable to combination into more general theories? The papers of the fourth GTSE Workshop addressed these questions by means of what can be collectively refer to as Separability Principles . In a sense, participants used well known techniques applied to design software systems to design SE theories. Separability is a powerful tool for understanding relations among SE candidate theories and guide how to assemble sub-theories into a general framework. Participants enthusiastically debated a series of related issues. The specialized vs. general theories questions were raised in diverse forms, such as, SE meaning multiple things, good predictive theories for narrow problems, ability of General theories to generate specific theories, and last but not least, whether "General" capture the contents of the workshop itself. The 4th GTSE edition was collocated with ICSE 2015 (International Conference of Software Engineering) in Firenze, Italy

In the current state of software engineering, component-based software development is one of the most alluring paradigms for developing large and complex software products. In this software engineering methodology pre-engineered, pre-tested, context-based, adaptable, deployable software components are assembled according to a predefined architecture. Rather than developing a system from scratch, component-based software development emphasizes the integration of these components according to the user's requirements and specifications. In component-based software, the components interact to access and provide services and functionality to each other. Currently, the emphasis of industry and researchers is on developing impressive and efficient metrics and measurement tools to analyze the interaction complexity among these components. To represent the request and the response of services among components, we have used outgoing edges and incoming edges respectively. In this paper we have defined these interactions as In-Interactions and Out-Interactions. The metrics proposed in this paper are solely based on the interactions among the components. In this work some simple methods and metrics for computing the complexity of composable components are suggested. The metrics discussed in this paper include the computation of interaction complexities as Total-Interactions of a component, Total- Interactions of component-based software, Interaction-Ratio of a component, Interaction-Ratio of component-based software, Average- Interaction among components and Interaction-Percentage of components.

Automated software testing is the only resort for delivering quality software, since there are usually large test suites to be executed, especially for regression testing. Though many automated testing tools and techniques have been developed, they still do not solve all problems like cost and maintenance, and they can even be brittle in some situations, thus confining their adoption. To address these issues, we develop a pattern-based automated testing framework, called UTF (User-oriented Testing Framework), for Web applications. UTF encodes textual-visual information about and relationships between widgets into a domain specific language for test scripts based on the underlying invariant structural patterns in the DOM, which allows test scripts to be easily created and maintained. In addition, UTF provides flexible extension and customization capabilities to make it adaptable for various Web-application scenarios. Our experiences show UTF can greatly reduce the cost of adopting automated testing and facilitate its institutionalization.

Complex, soft-real-time system development is one of the challenges in the software industry, as it is difficult to understand, test and maintain such systems. However, the software development goal is to operate reliably despite this complexity. This can be achieved by applying formal methods, which use a language that has a strong mathematical foundation for describing the system. To be more specific, model-based specification languages are used to resolve ambiguities in user requirements or detect design errors early in the software life cycle. This paper compares object-oriented model-based formal languages such as Zed (Z), Vienna Development Method (VDM) and Object Constraint Language (OCL) based on various factors. Also, the issues surrounding the application of these formal methods to various software problems are discussed in this paper. The present research work enables software developers to select an appropriate language suiting their specific requirements.

Software is a major component of any computer system. To maintain the quality of software, early fault localization is necessary. Many different fault-localization methods have been used by researchers. Ideally, methods for fault-localization are used in such a way that one is able to detect as many faults as possible using the least resources. But, in general, it is hard to predict a test suite's fault-localization capability. This paper gives a review of the previous studies that are related to software fault-localization methods. It reviews various journal and conference papers on localization of faults and various methods for localization of faults proposed in the literature.

In this paper, we propose to evaluate Web-specific Goal Driven Models to choose amongst various design alternatives, deal with conflicts, check completeness and reaffirm the sanity of the model. The work is based on Web specific User Requirements Notation (WebURN), which is an enhancement of a goal and scenario based standard, User Requirements Notation (URN). We present the forward reasoning approach for finding the satisfaction level of the root/parent goals from the sub-goals in the goal model. The Quantitative Reasoning method called Forward Reasoning and Evaluation: Numeric (FREN) is apt when enough domain knowledge is there and precise results are expected. We propose a Quantitative Reasoning and Evaluation approach in this paper wherein the requirements engineer has an estimate of the satisfaction level of tasks and knows the priorities of various goals and sub-goals. The rules for propagation of satisfaction values from the leaves to the root level goals are specified in detail. The approach is then applied to the Web-specific Goal driven Requirements models for evaluation. The methodology has been implemented in the WebURN tool, built upon Microsoft Visio for editing and analyzing the WebURN diagrams. The results of evaluations are also compared with other prominent approaches in the area of Goal oriented Requirements Engineering. The methodology used for evaluation enables choice amongst design alternatives, resolves conflicts automatically and incorporates the role of priority in making design decisions.