Component Programming — a fresh look at software components

In this article the advances in software engineering are i) evolvement of software processes from rigid, sequential and slow processes to iterative and agile processes and standardization of process models, such as CMMI (Capability Maturity Model Integration) and ISO 12207, ii) programming paradigms and software design techniques, such as object-oriented programming and model-driven architecture, iii) various techniques for software reuse, such as design patterns and component-based software development, iii) formal methods for software specification and verification, and numerous methods for software testing, iv) software architecture, such as event-driven architecture and service-oriented architecture, and architecture description languages. All these advances aim at improving the quality of software, reducing cost, and promoting software reuse.

In central fields of software engineering, there are two competing directions of research.Component frameworks and advanced programming languages both seek to improve fundamental software quality properties, most notably: modularity.While both directions have produced specific benefits, harvesting these benefits still requires a trade-off in selecting one of the two technologies.In this paper, we present the integration of the aspect-oriented programming language ObjectTeams/Java into the OSGi component framework.By combining these technologies, the design space for modular architectures of components and applications is enriched with fundamentally new options.As a result, the best of both worlds is available for re-using software modules at realistic scales and for evolving systems over significant periods of time.

Component-based Development (CBD) is an important emerging topic in Software Engineering, promising long sought after benefits like increased reuse and reduced time-to-market (and hence software production cost). However, there are at present many obstacles to overcome before CBD can succeed. For one thing, CBD success is predicated on a standardised market place for software components, which does not yet exist. In fact currently CBD even lacks a universally accepted terminology. Existing component models adopt different component definitions and composition operators. Therefore much research remains to be done. We believe that the starting point for this endeavour should be a thorough study of current component models, identifying their key characteristics and comparing their strengths and weaknesses. A desirable side-effect would be clarifying and unifying the CBD terminology. In this tutorial, we present a clear and concise exposition of all the current major software component models, including a taxonomy. The purpose is to distill and present knowledge of current software component models, as well as to present an analysis of their properties with respect to commonly accepted criteria for CBD. The taxonomy also provides a starting point for a unified terminology.

It is increasingly recognised that successful Software Engineering not only depends on technical or process issues, but requires attention to human factors. Researchers include such aspects which has led to both new theories and refined methods. However, it is not clear if professionals in the software industry agree that human factors are critical and what the related challenges and possibilities are. The purpose of the present study is to address this discrepancy. Using a qualitative research method, we elicited information about how and why human factors affect Software Engineering projects, which challenges are of special interest and the context in which they arise. Thematic analysis of data from interviews with nine senior software professionals in multiple Swedish software companies of differing size identified four main challenging areas. As supported by existing research, customer relations and communications were highlighted as important, but so too is the need for more holistic and multi-dimensional solutions and the importance of human factors in software organisational change. In addition, quantitative results indicate that the professionals see the organisational and group aspects as more important than the individual aspect. Our results can help to focus future research on matters that software practitioners consider important.

Component based software development (CBSD) endeavors to deliver cost-effective and quality software systems through the selection and integration of commercially available software components. CBSD emphasizes the design and development of software systems using preexisting components. Software component reusability is an indispensable part of component based software development life cycle (CBSDLC), which consumes a significant amount of organization’s resources, that is, time and effort. It is convenient in component based software system (CBSS) to select the most suitable and appropriate software components that provide all the required functionalities. Selecting the most appropriate components is crucial for the success of the entire system. However, decisions regarding software component reusability are often made in an ad hoc manner, which ultimately results in schedule delay and lowers the entire quality system. In this paper, we have discussed the analytic network process (ANP) method for software component selection. The methodology is explained and assessed using a real life case study.

Context:Deep learning (DL) techniques have gained significant popularity among software engineering (SE) researchers in recent years. This is because they can often solve many SE challenges without enormous manual feature engineering effort and complex domain knowledge.Objective:Although many DL studies have reported substantial advantages over other state-of-the-art models on effectiveness, they often ignore two factors:(1) reproducibility—whether the reported experimental results can be obtained by other researchers using authors’ artifacts (i.e., source code and datasets) with the same experimental setup; and(2) replicability—whether the reported experimental result can be obtained by other researchers using their re-implemented artifacts with a different experimental setup. We observed that DL studies commonly overlook these two factors and declare them as minor threats or leave them for future work. This is mainly due to high model complexity with many manually set parameters and the time-consuming optimization process, unlike classical supervised machine learning (ML) methods (e.g., random forest). This study aims to investigate the urgency and importance of reproducibility and replicability for DL studies on SE tasks.Method:In this study, we conducted a literature review on 147 DL studies recently published in 20 SE venues and 20 AI (Artificial Intelligence) venues to investigate these issues. We also re-ran four representative DL models in SE to investigate important factors that may strongly affect the reproducibility and replicability of a study.Results:Our statistics show the urgency of investigating these two factors in SE, where only 10.2% of the studies investigate any research question to show that their models can address at least one issue of replicability and/or reproducibility. More than 62.6% of the studies do not even share high-quality source code or complete data to support the reproducibility of their complex models. Meanwhile, our experimental results show the importance of reproducibility and replicability, where the reported performance of a DL model could not be reproduced for an unstable optimization process. Replicability could be substantially compromised if the model training is not convergent, or if performance is sensitive to the size of vocabulary and testing data.Conclusion:It is urgent for the SE community to provide a long-lasting link to a high-quality reproduction package, enhance DL-based solution stability and convergence, and avoid performance sensitivity on different sampled data.

Software Engineering: A Methodical Approach (Second Edition) provides a comprehensive, but concise introduction to software engineering. It adopts a methodical approach to solving software engineering problems, proven over several years of teaching, with outstanding results. The book covers concepts, principles, design, construction, implementation, and management issues of software engineering. Each chapter is organized systematically into brief, reader-friendly sections, with itemization of the important points to be remembered. Diagrams and illustrations also sum up the salient points to enhance learning. Additionally, the book includes the author’s original methodologies that add clarity and creativity to the software engineering experience. New in the Second Edition are chapters on software engineering projects, management support systems, software engineering frameworks and patterns as a significant building block for the design and construction of contemporary software systems, and emerging software engineering frontiers. The text starts with an introduction of software engineering and the role of the software engineer. The following chapters examine in-depth software analysis, design, development, implementation, and management. Covering object-oriented methodologies and the principles of object-oriented information engineering, the book reinforces an object-oriented approach to the early phases of the software development life cycle. It covers various diagramming techniques and emphasizes object classification and object behavior. The text features comprehensive treatments of: Project management aids that are commonly used in software engineering An overview of the software design phase, including a discussion of the software design process, design strategies, architectural design, interface design, database design, and design and development standards User interface design Operations design Design considerations including system catalog, product documentation, user message management, design for real-time software, design for reuse, system security, and the agile effect Human resource management from a software engineering perspective Software economics Software implementation issues that range from operating environments to the marketing of software Software maintenance, legacy systems, and re-engineering This textbook can be used as a one-semester or two-semester course in software engineering, augmented with an appropriate CASE or RAD tool. It emphasizes a practical, methodical approach to software engineering, avoiding an overkill of theoretical calculations where possible. The primary objective is to help students gain a solid grasp of the activities in the software development life cycle to be confident about taking on new software engineering projects.

Recent advances in programming languages have sometimes drastically altered program structure as in the Reduction Languages of Backus (3) or produced less drastic but nonetheless dramatic effects like the elimination of the “goto” statement in an increasing number of “structured” programming languages (4). Now waiting in the wings are demands for topologically simpler program structures which will ease code optimization problems, increase programmer productivity, and aid automatic verification of program correctness. In these respects, perhaps the most advanced high-level programming language yet developed is Aiken Dynamic Algebra (ADA), the younger sister of APL (5, 6, 7). Boyce (8) has already shown the improved efficiency of ADA on pipeline and parallel machines, but his results for ADA in a sequential environment were inconclusive. This study reports the comparison of a sequential ADA implementation with the standard instruction sets of two existing sequential machine designs, the IBM 1130 and the IBM 360. Addition of 150 microinstructions allowed simultaneously a 5 to 35% decrease in execution time and a 5 to 40% decrease in the storage requirements for code to implement identical algorithms.

Recent advances in programming languages have sometimes drastically altered program structure as in the Reduction Languages of Backus (3) or produced less drastic but nonetheless dramatic effects like the elimination of the “goto” statement in an increasing number of “structured” programming languages (4). Now waiting in the wings are demands for topologically simpler program structures which will ease code optimization problems, increase programmer productivity, and aid automatic verification of program correctness. In these respects, perhaps the most advanced high-level programming language yet developed is Aiken Dynamic Algebra (ADA), the younger sister of APL (5, 6, 7). Boyce (8) has already shown the improved efficiency of ADA on pipeline and parallel machines, but his results for ADA in a sequential environment were inconclusive. This study reports the comparison of a sequential ADA implementation with the standard instruction sets of two existing sequential machine designs, the IBM 1130 and the IBM 360. Addition of 150 microinstructions allowed simultaneously a 5 to 35% decrease in execution time and a 5 to 40% decrease in the storage requirements for code to implement identical algorithms.

Software development communities have made the true venture to software development through the concept of component-based software approach and commercial off-the-shelf (COTS). Majority of the present software applications have software components as the basic elements, and component-based software development (CBSD) has been successful in building applications and systems. However, the security of CBS for the software component is still not properly noticed. Developing secure software is the accountability of all the stakeholders involved with component-based software development model. The main challenge is to access how much security we have achieved or how can we predict and evaluate the security at the early stage of software development? Software security has a very constructive impact on software productivity, maintainability, cost, and quality. Therefore, more early we introduce and evaluate security into component-based software more productivity and quality we can achieve. In this paper, efforts are done to provide some suitable guiding principle to the software engineers in the development of secure component-based software products. This paper also discusses the overview of requirement specification and analyzes the software architectures and design for developing secure component-based software products.

Software engineers are expected to possess a variety of technical, social and personal competencies to be well prepared for real world working environments. At the German University in Cairo (GUC), we were able to guide large groups of students into becoming self managing and self learning communities whose members work together as a team to build large scale software. The students were able to experience many of the challenges in software engineering and develop a variety of related skills in a short period of time. This report describes our detailed experience in reaching such results using agile development practices in a simulated enterprise environment. With an aim to enable educators realise the same success, this report serves as a guide for educators who wish to replicate the process. The resulting successes and the concerns from this unique experience are discussed along with future recommendations.

The field of theoretical computer science has had a long tradition of providing wonderful edited books to honor various prominent members of the community. The idea behind such edited works is clear: celebrate the work of a particular researcher by having co-authors and colleagues write papers on subjects related to the researcher's body of work. When successful, such a project provides for a wonderful excursion through the work of a researcher, often highlighting an underlying coherence to that work.On that account, the book Proof, Language, and Interaction: Essays in the Honor of Robin Milner (edited by Plotkin, Stirling and Tofte) is a success. In no small part this is due to Milner's span of work from theory to practice. It is hard to both briefly describe Milner's contributions and give an idea of the breadth of his effort. Two major tracks of research emerge. First, after some work with John McCarthy's AI group at Stanford, he developed LCF (specifically, Edinburgh LCF), a system for computer-assisted theorem proving based on Dana Scott's idea on continuous partial functions for denotational semantics. Not only working on the implementation, Milner also worried about the semantic foundations [1]. LCF came with a programming language, Edinburgh ML, which evolved with Milner's help into standard ML, a higher-order language that introduced many features now standard in advanced programming language, features such as polymorphism and type inference [4]. His second track of research involves concurrency. He invented CCS, the calculus of communicating systems [2]. Work on the semantics of CCS went from the traditional domain-theoretic approach to a new operational view of processes equality based on the notion of bisimulation. Subsequent work by Milner led to the development of other calculi, most notably the π-calculus, which included a powerful notion of mobility [3]. His later work in the area attempted to provide a unifying framework for comparing calculi, and unifying sequential and concurent computation.This range of interests is reflected in the table of contents of the book. The book splits across different subjects: semantic foundations, where we discover work aimed at understanding computation, both sequential and concurrent, programming logic, where we discover work derived from Milner's work on LCF, and aimed at understanding the role of formal mathematics, programming languages, where we discover Standard ML, and other languages based on Milner's idea about concurrent calculi, concurrency, where we discover work on Milner's early CCS approach and extensions, and mobility, where we discover work related to the π-calculus.

Abstract- A major challenge in teaching software engineering to undergraduates is that most students have limited industry experience, so the problems addressed are unknown and hence unappreciated. Issues of scope prevent a realistic software engineering experience, and students often graduate with a simplistic view of software engineering’s challenges. Problems and Programmers (PnP) is a competitive, physical card game that simulates the software engineering process from requirements specification to product delivery. Deliverables are abstracted, allowing a focus on process issues and for lessons to be learned in a relatively short time. The rules are easy to understand and the game’s physical nature allows for face-to-face interaction between players. The game’s developers have described PnP in previous publications, but this paper reports the game’s use within a larger educational scheme. Students learn and play PnP, and then are required to create a software requirements specification based on the game. Finally, students reflect on the game’s strengths and weaknesses and their experiences in an individual essay. The paper discusses this approach, students ’ experiences and overall outcomes, and offers an independent, critical look at the game, its use, and potential improvements.

Safe is a clean-slate design for a secure host architecture. It integrates advances in programming languages, operating systems, and hardware and incorporates formal methods at every step. Though the project is still at an early stage, we have assembled a set of basic architectural choices that we believe will yield a high-assurance system. We sketch the current state of the design and discuss several of these choices.

Research on features has received much attention in the domain engineering community. Feature modeling plays an important role in the design and implementation of complex software systems. However, the presentation and analysis of feature models are still largely informal. There is also an increasing need for methods and tools that can support automated feature model analysis. This paper presents a formal engineering approach to the specification and verification of feature models. A formal semantics for the feature modeling language is defined using first-order logic. It provides a precise and rigorous formal interpretation for the graphical notation. In addition, further validation of the semantics using the Z/EVES theorem prover is presented. Finally, we demonstrate that the consistency of a feature model and its configurations can be automatically verified by encoding the semantics into the Alloy Analyzer. A case study of the Key Word in Context (KWIC) index systems feature model is presented to illustrate the verification process.