Search

Examines the history of major achievements in computer science as portrayed by winners of the prestigious Turing award and identifies a possibly unique activity called Theory-Guided Technology (TGT). Researchers develop TGT by using theoretical results to create practical technology. Discusses reasons why TGT is practical in computer science and the cool reception that software engineers have given TGT. (Author/ASK)

Security is an afterthought process for the development of software in earlier days but now the time has been changed. Now, security is on top priority and involved from the beginning of software development. Security requirements are the prime concern for the development and quality of any software product. The specification and verification of security requirements need a lot of attention from the computer science community in the process of the software development life cycle. Formal Methods are a widely used and well‐recognized approach for the specification and verification of any safety‐critical system. Formal methods play an important role in the requirement phase to the design phase of software development. In this study, we summarized the outcomes of related papers to find out the current state of the art in the proposed area. In this manuscript, three research questions are frame and we try to find the answer to these research questions to the best of our effort and knowledge. The objective of this research paper is to find out the gap analysis, state of art, and trends in the proposed area. The academician needs to pursue more effort toward the formal specification of security requirements, providing a deeper understanding to help security experts in the development of systems. [ABSTRACT FROM AUTHOR]

The Hook model is used in digital products to engage and retain users through the mechanism of habit formation. This paper explores the use of Hook model techniques in two mobile applications, one being a popular taxi service (Uber taxi) and the other a social network (Instagram). The goal of this paper is to explore the Hook cycle patterns in the two products, and to identify commonalities and differences in how they are applied. Our results suggest that Hook cycle patterns appear with similar frequency; however, Instagram includes more internal Trigger calls. Uber uses fewer triggers to encourage usage, most probably because users already have a specific need for the application. For the same reason, Uber has less opportunity to fail in the reward delivery, while Instagram can use the failure (in providing a reward) as another trigger if the usage habit is already established. In addition, we introduce two types of Hook cycle patterns: internal (within a single use case) and external (transition between use cases). The insights obtained through the case studies serve as a practical reference for developing engaging and retention-focused applications. [ABSTRACT FROM AUTHOR]

The field of statistical computing is rapidly developing and evolving. Shifting away from the formerly siloed landscape of mathematics, statistics, and computer science, recent advancements in statistical computing are largely characterized by a fusing of these worlds; namely, programming, software development, and applied statistics are merging in new and exciting ways. There are numerous drivers behind this advancement, including open movement (encompassing development, science, and access), the advent of data science as a field, and collaborative problem-solving, as well as practice-altering advances in subfields such as artificial intelligence, machine learning, and Bayesian estimation. In this paper, we trace this shift in how modern statistical computing is performed, and that which has recently emerged from it. This discussion points to a future of boundless potential for the field. [ABSTRACT FROM AUTHOR]

Summary: Automated measurement programs are an efficient way of collecting, processing, and visualizing measures in large software development companies. The number of measurements in these programs is usually large, which is caused by a diversity of the needs of the stakeholders. In this paper, we present the application of the self‐healing concepts to assure the availability of measurements to the stakeholders without the need for effort‐intensive and costly manual interventions of the operators. We study the measurement infrastructure at one of the development units of a large infrastructure provider. In this paper, we present how the Monitor, Analyze, Plane, and Execute with Knowledge model was instantiated in a simplistic manner to reduce the need for manual intervention in the operation of the measurement systems. Based on the experiences from the 2 cases studied in this paper, we show how an evolution toward self‐healing measurement systems is done both with a dedicated failure taxonomy and with an effective straightforward handling of the most common errors in the execution. The mechanisms studied and presented in this paper show that self‐healing provides significant improvements to the operation of the measurement program and reduces the need for daily oversight by an operator for the measurement systems. [ABSTRACT FROM AUTHOR]

In the early stage of software development, a software requirements specification (SRS) is essential, and whether the requirements are clear and explicit is the key. However, due to various reasons, there may be a large number of misunderstandings. To generate high-quality software requirements specifications, numerous researchers have developed a variety of ways to improve the quality of SRS. In this paper, we propose a questions extraction method based on SRS elements decomposition, which evaluates the quality of SRS in the form of numerical indicators. The proposed method not only evaluates the quality of SRSs but also helps in the detection of defects, especially the description problem and omission defects in SRSs. To verify the effectiveness of the proposed method, we conducted a controlled experiment to compare the ability of checklist-based review (CBR) and the proposed method in the SRS review. The CBR is a classic method of reviewing SRS defects. After a lot of practice and improvement for a long time, CBR has excellent review ability in improving the quality of software requirements specifications. The experimental results with 40 graduate students majoring in software engineering confirmed the effectiveness and advantages of the proposed method. However, the shortcomings and deficiencies of the proposed method are also observed through the experiment. Furthermore, the proposed method has been tried out by engineers with practical work experience in software development industry and received good feedback. [ABSTRACT FROM AUTHOR]

Software models' comparison is an operation performed in all software development lifecycle processes. Comparison is one of the steps of software models refactoring, refinement, merging, quality estimation, etc. Such operations take place in different tasks in requirement analysis, software designing, testing, reengineering, etc. This article proposes analytical foundations for software models' representation and corresponding technique for their comparison. To describe software model structure it is proposed to use graph representation. Software models' comparison technique based on subgraphs matching is proposed. Following this technique important steps of software tool realization are described, namely, (i) grounding of the choice of development environment and tools for XMI files processing; (ii) the algorithm for extracting software model structure from XMI file; (iii) software models' comparison algorithm realization; (iv) description of software architecture. Peculiarity of proposed software tool is a possibility for visualizing elements of two software models that do not match each other directly in modeling environment. Data are extracted from XMI files by means of LINQ queries. After that they are stored in graph triples. To perform visualization, it is proposed to modify "layout" files, designed by Microsoft Visual Studio environment. Other important feature of the tool is a possibility to compare software models, designed in different modeling environments. It is done by means of involving new LINQ queries, considering specifics of storing software models in different modeling environments. Paper contains case study, explaining the process of software models'analytical representation, and comparison technique implementation. [ABSTRACT FROM AUTHOR]

Embedded system is a hot topic in the field of computer science and cybernetics at home and abroad in recent years. This paper has analyzed the scale and complexity of embedded systems, including modeling in embedded realtime software development process. Meanwhile, this paper analyzes and compares the current ideas and methods of modeling embedded real-time software, and studies the shortcomings of the timing characteristics in the modeling of embedded real-time software, which is based on the research of the common techniques and methods for the expansion of timing features. A new method of modeling embedded real-time software based on timing characteristics is proposed. The formal syntax and sequential logical semantics of each interactive view of timing characteristics are defined. The proposed modeling method is applied to the embedded real-time software instance. This paper has certain positive significance to research on modeling of embedded real-time software, and formal semantics of timing features and methods in the application of software development. [ABSTRACT FROM AUTHOR]

Background and Context: Non-traditional training grounds such as coding boot camps that attract a higher proportion of women are important sites for understanding how to broaden participation in computing. Objective: This work aims to help us better understand the women choosing boot camps and their pathways through these camps and into the computing workforce. Method: This paper reports on a longitudinal, qualitative study investigating female boot camp attendees. Findings: Findings show that women attending boot camps are career changers that develop an interest in software development too late to major in CS, discovering a post-college enjoyment of programming undertaken to support work goals at a current job or an aspirational job. Implications: Women at boot camps illustrate a missed opportunity to diversify postsecondary CS classrooms when not recruited early, not given interdisciplinary options, not exposed to enjoyable programming tasks, and not exposed to the array and number of job prospects. [ABSTRACT FROM AUTHOR]

Aspect-Oriented Modeling (AOM) techniques allow software designers to isolate and address separately solutions for crosscutting concerns (such as security, reliability, new functional features, etc.). Current AOM research is concerned not only with the separate expression of concerns and their composition into a complete system model, but also with the analysis of different properties of such models. This paper proposes an approach for analyzing the performance effects of a given aspect on the overall system performance, after the composition of the aspect model with the system’s primary model. Performance analysis of UML models is enabled by the “UML Performance Profile for Schedulability, Performance and Time” (SPT) standardized by OMG, which defines a set of quantitative performance annotations to be added to a UML model. The first step of the proposed approach is to add performance annotations to both the primary and the aspect models. An aspect model is generic at first, and therefore its performance annotations must be parameterized. A generic model is converted into a context-specific aspect model with concrete values assigned to its performance annotations. The latter is composed with the primary model, generating a complete annotated UML model. The composition is performed in both structural and behavioural views. A novel approach for composing activity diagrams based on graph-rewriting concepts is proposed in the paper. The next step is to transform automatically the composed model into a Layered Queueing Network (LQN) performance model, by using techniques developed in previous work. The proposed approach is illustrated with a case study system, whose primary model is enhanced with some security features by using AOM. The performance effects of the security aspect under consideration are analyzed in two design alternatives, by solving and analyzing the LQN model of the composed system. [ABSTRACT FROM AUTHOR]

Software regression testing techniques verify previous functionalities each time software modifications occur or new characteristics are added. With the aim of gaining a better understanding of this subject, in this work we present a survey of software regression testing techniques applied in the last 15 years; taking into account its application domain, kind of metrics they use, its application strategies and the phase of the software development process where they are applied. From an outcome of 460 papers, a set of 25 papers describing the use of 31 software testing regression techniques were identified. Results of this survey suggest that at the time of applying a regression testing techniques, metrics like cost and fault detection efficiency are the most relevant. Most of the techniques were assessed with instrumented programs (experimental cases) under academic settings. Conversely, we observe a minimum set of software regression techniques applied in industrial settings, mainly, under corrective and maintenance approaches. Finally, we observe a trend using some regression techniques under agile approaches. [ABSTRACT FROM AUTHOR]

With the gradual maturity of component oriented software development method, component-based software evolution technology has become hot research in academia and industry. Although many evolution rules are designed, they rarely consider component type-mismatched problem in evolution rules. This has led to evolution rules that often run error in software evolution execution. Hence, focusing on the mismatch problem of component type in software evolution, this paper addresses various evolution rules with condition constrains to support component type matching. First, we use the bigraph theory to model the software architecture and employ bigraph term language to describe the basic component evolution operations. Second, we join type system into the term language and use the type term language to express the condition constraints on position and connection for component evolution rules. These condition constraints can guarantee the type-matched among components that participate in software evolution. Furthermore, we show that the component type-matched still kept during a number of different evolution rules are used in the whole software evolution reaction system. Finally, two cases study of evolution progress of ATM system and tourism information system are presented. Two cases illustrate the effectiveness of our approach. [ABSTRACT FROM AUTHOR]

Synthesis of behavior models from software development artifacts such as scenario-based descriptions or requirements specifications helps reduce the effort of model construction. However, the models favored by existing synthesis approaches are not sufficiently expressive to describe both universal constraints provided by requirements and existential statements provided by scenarios. In this paper, we propose a novel synthesis technique that constructs behavior models in the form of Modal Transition Systems (MTS) from a combination of safety properties and scenarios. MTSs distinguish required, possible, and proscribed behavior, and their elaboration not only guarantees the preservation of the properties and scenarios used for synthesis but also supports further elicitation of new requirements. [ABSTRACT FROM AUTHOR]

Abstract  Transformational approaches to generating design and implementation models from requirements can bring effectiveness and quality to software development. In this paper we present a framework and associated techniques to generate the process model of a service composition from a set of temporal business rules. Dedicated techniques including path-finding, branching structure identification and parallel structure identification are used for semi-automatically synthesizing the process model from the semantics-equivalent Finite State Automata of the rules. These process models naturally satisfy the prescribed behavioral constraints of the rules. With the domain knowledge encoded in the temporal business rules, an executable service composition program, e.g., a BPEL program, can be further generated from the process models. A running example in the e-business domain is used for illustrating our approach throughout this paper. [ABSTRACT FROM AUTHOR]

The motivation for this work is derived from the current interest in speeding up development schedules for information technology (IT) projects. A key implication of the shift to more rapid development methods is the growing emphasis on fixed time and fixed effort delivered during such projects. However, there appears to be little work that addresses the impacts of dealing with bound effort levels. The result of binding time and effort is to deprive project managers of the normal parameters that are used in trade-offs. The paper introduces a quantitative analytical framework for modeling effort-boxed development in order to uncover the effects on the overall development effort and the potential leverage that can be derived from incremental delivery in such projects. Models that predict product size as an exponential function of the development effort are used in the paper to explore the relationships between effort and the number of increments, thereby providing new insights into the economic impact of incremental approaches to effort-boxed software projects. [ABSTRACT FROM AUTHOR]

Understanding the business is an important step in information system (IS) development. Conceptual models are descriptions of the organizational context for which a system is developed, and are used to help understanding this context. However, conceptual modelling methods do not provide well-formalized ways to create domain descriptions. On the other hand, in the area of IS design and software modelling, languages exist (such as UML) that possess a high level of formality. Extending the use of these IS design languages to conceptual modelling, even though they have not been specifically intended for this, can lead to several advantages. In particular, it can enable the use of similar notation in several stages of system development. However, while object-oriented constructs such as “object” and “operation” have clear meaning in the context of software design, it is not clear what they might mean in terms of the application domain, and no rules or guidelines exist for using them to create useful descriptions of such domains. This paper suggests specific semantics for object-oriented constructs based on a mapping between ontologically derived concepts and object-oriented language constructs. The paper also proposes modelling rules to guide the construction of object-oriented conceptual models and to assure that such models describe only ontologically feasible application domain situations. While the results are applicable to object-oriented constructs in general, UML is used as an example. A case study to test the use of the proposed semantics and modelling rules is described. [ABSTRACT FROM AUTHOR]

This positioning paper focuses on the selection of software for educational purposes and how the selection process may encourage usage. Computer Aided Software or Systems Engineering (CASE) tools provided an appropriate e software example for this study. The paper also seeks to examine if the use of Information Communication Technology (ICT) such as CASE can aid the students' understanding of systems analysis and design techniques. Entity relationship modelling has been used as the primary technique. Focus groups comprising postgraduate and undergraduate students were used as the main data collection instrument supported by a pre and post assessment test. The findings provided a clear indication of which CASE tool the participants found easiest to use and which tool they were interested in using. It was further found that some tools have unique properties that may assist the user in their understanding. This paper also provides a valuable platform for defining future research in this area. [ABSTRACT FROM AUTHOR]

Many teachers experience serious problems when teaching object-orientation to beginners or professionals. Many of these problems could be overcome or reduced thorough the use of more appropriate tools. In this paper, we introduce BlueJ, an integrated development environment designed for teaching object-orientation, and discuss how the use of this tool can change the approach to teaching. [ABSTRACT FROM AUTHOR]

The need to manage the immense complexity in software engineering makes tools and methods essential, and requires that they be designed in accordance with well- defined principles. Surprisingly, there is yet no explicit body of knowledge for designing diagrammatic modeling languages (DMLs), despite the fact that they are used extensively as the primary conceptual modeling tools in software engineering. This paper provides an overview of the new and growing field of DML design that aims at compiling such a body of knowledge. The paper starts with relevant definitions and a brief introduction of the current defacto standard DML of software engineering called the Unified Modeling Language (UML), and offers a short account of efforts and directions in DML design. [ABSTRACT FROM AUTHOR]

The current educational climate provides both incentives and pressures to extend the use of information technology in university teaching. The computer science discipline is ideally placed to take a leading role in the development of technology-based teaching tools. In recent times the technological resources available for such initiatives have also taken a leap forward, not least with the release of the rapidly developing Java language. This paper reports on one such initiative—the development of a system for providing automatic feedback on computer science laboratory work and monitoring student progress. The paper outlines the goals of the system and shows that the collection of facilities afforded by the Java language provides a strong foundation for the development of software for securely analyzing student code. [ABSTRACT FROM AUTHOR]

Minimization of data-processing time and reduction of software-development time are important practical problems to be tackled by modern computer science. This paper presents the authors' proposal of a family of statistical models for the estimation of program execution time, which is an approach focused on both of the above problems at the same time. The family consists of a general model and specific models and has been elaborated based on empirical data collected for pattern-program loops representing some arbitrarily selected features related to the program structure and the specificity of a program-execution environment. The paper presents steps to elaborate the aforementioned family as well as the results of the carried-out experimental research. The paper demonstrates how the elaborated models can be applied in iterative compilation for optimization purposes, allowing us to reduce the time of software development and produce code with minimal execution time. [ABSTRACT FROM AUTHOR]

Due to the increasing scale and complexity of software products, software maintenance especially on bug resolution has become a challenging task. Generally in large-scale software programs, developers depend on software artifacts (e.g., bug report, source code and change history) in bug repositories to complete the bug resolution task. However, a mountain of submitted bug reports every day increase the developers' workload. Therefore, 'How to effectively resolve software defects by utilizing software artifacts?' becomes a research hotspot in software maintenance. Considerable studies have been done on bug resolution by using multi-techniques, which cover data mining, machine learning and natural language processing. In this paper, we present a literature survey on tasks, challenges and future directions of bug resolution in software maintenance process. Our investigation concerns the most important phases in bug resolution, including bug understanding, bug triage and bug fixing. Moreover, we present the advantages and disadvantages of each study. Finally, based on the investigation and comparison results, we propose the future research directions of bug resolution. [ABSTRACT FROM AUTHOR]

Automatic generation of textual artefacts (including code, documentation, configuration files, build scripts, etc.) from models in a software development process through the application of model-to-text (M2T) transformation is a common MDE activity. Despite the importance of M2T transformation, contemporary M2T languages lack support for developing transformations that scale with the size of the input model. As MDE is applied to systems of increasing size and complexity, a lack of scalability in M2T transformation languages hinders industrial adoption. In this paper, we propose a form of runtime analysis that can be used to identify the impact of source model changes on generated textual artefacts. The structures produced by this runtime analysis, property access traces, can be used to perform efficient source-incremental transformation: our experiments show an average reduction of 60% in transformation execution time compared to non-incremental (batch) transformation. [ABSTRACT FROM AUTHOR]

Defects in computer-based systems (CBS) can adversely affect systems development efforts and can present serious legal challenges to developers. Of particular significance are the torts of strict products liability and negligence that can arise as a result of harm or injury resulting from, among other things, poor testing of systems, inadequate warnings, or failure to use state-of-the-art technology. The threat of injury has caused federal and state agencies and legislatures to consider seriously courses of action to inhibit the more injurious effects of such systems. This paper examines these two torts in some detail and illustrates how CBS developers could be threatened as a result of defective systems. We also present a framework for injury assessment and reduction of legal liability that can be used to guide CBS developers in assessing the possibility of injury resulting from development flaws. Further, the framework aids developers in their decision-making process by identifying appropriate measures to take to reduce their legal liability arising from what could be determined to be faulty systems development efforts. In addition, the use of the measures suggested by our framework might provide safer systems to avoid harming individuals. [ABSTRACT FROM AUTHOR]

Event-based communication is used in different domains including telecommunications, transportation, and business information systems to build scalable distributed systems. Such systems typically have stringent requirements for performance and scalability as they provide business and mission critical services. While the use of event-based communication enables loosely-coupled interactions between components and leads to improved system scalability, it makes it much harder for developers to estimate the system's behavior and performance under load due to the decoupling of components and control flow. In this paper, we present our approach enabling the modeling and performance prediction of event-based systems at the architecture level. Applying a model-to-model transformation, our approach integrates platform-specific performance influences of the underlying middleware while enabling the use of different existing analytical and simulation-based prediction techniques. In summary, the contributions of this paper are: (1) the development of a meta-model for event-based communication at the architecture level, (2) a platform aware model-to-model transformation, and (3) a detailed evaluation of the applicability of our approach based on two representative real-world case studies. The results demonstrate the effectiveness, practicability and accuracy of the proposed modeling and prediction approach. [ABSTRACT FROM AUTHOR]

Design patterns have gained popularity as they provide strategies for solving specific problems. This paper explores two common design patterns in iOS development field: Model View Controller (MVC) and Model View ViewModel (MVVM) design patterns. The paper investigates the problems with MVC design pattern. Then, it introduces a validation model that detects MVC problems, and helps programmers make the decision to switch between MVC and MVVM design pattern. The proposed validation model consists of two phases: phase one is to detect MVC problems, and phase two is to validate the relation between MVVM objects. The model was then applied to a Cloudy app as a case study. As a result, the model was able to detect MVC problems. The relation between MVVM objects was also validated. Further, this research provided some recommended solutions to satisfy the relations between MVVM objects in the project. [ABSTRACT FROM AUTHOR]

Summary: Function call interception (FCI), or method call interception (MCI) in the object‐oriented programming domain, is a technique of intercepting function calls at program runtime. Without directly modifying the original code, FCI enables to undertake certain operations before and/or after the called function or even to replace the intercepted call. Thanks to this capability, FCI has been typically used to profile programs, where functions of interest are dynamically intercepted by instrumentation code so that the execution control is transferred to an external module that performs execution time measurement or logging operations. In addition, FCI allows for manipulating the runtime behavior of program components at the fine‐grained function level, which can be useful in changing an application's original behavior at runtime to meet certain execution requirements such as maintaining performance characteristics for different input problem sets. Due to this capability, however, some FCI techniques can be used as a basis of many security exploits for vulnerable systems. In this paper, we survey a variety of FCI techniques and tools along with their applications to diverse areas in the computing and software domains. We describe static and dynamic FCI techniques at large and discuss the strengths and weaknesses of different implementations in this category. In addition, we also discuss aspect‐oriented programming implementation techniques for intercepting method calls. [ABSTRACT FROM AUTHOR]

In this paper we propose architecture for a multirobot management system, ways of identifying the implementation challenges and analyzing how to address these challenges by using out-of-the-box features provided by .NET framework. We make a departure from using agent or robot specific development tools in order to take a fresh look at one of the industry leading general purpose development platforms that is .NET framework to analyze its applicability to multi-robot system development. For verification of the proposed ideas in practice, a multi-robot system is implemented using physical iRobot Roomba robots as the robot platform. [ABSTRACT FROM AUTHOR]

This paper describes five years of a software engineering education initiative led by Pace University in New York City. The initiative brought together faculty and students from across the globe to work on distributed software development projects, encompassing the Institute of Technology of Cambodia in Phnom Penh, the University of Delhi in India, Mahidol University in Thailand, the Royal University of Phnom Penh in Cambodia and the Ecole Supérieure Polytechnique in Senegal. The purpose of this paper is to show the trajectory that this initiative took over its first five years and to provide a resource for other instructors and institutions working on similar long-term global software development education initiatives. [ABSTRACT FROM AUTHOR]

What are the drivers for the burgeoning interest in agile methods? Have these drivers stimulated a similar rethinking on other fronts? What have we discovered? In this paper, I take a reflective stance in order to look at these larger issues and patterns. This stepping back is informed primarily by involvement in a multi-year research project on Quality Software Development @ Internet Speed and ongoing research on diffusion theory and the practices of technology adoption. This transition state is "between paradigms" and turbulent, marked by relentless change and volatility. The transition is a work in progress and by no means complete. [ABSTRACT FROM AUTHOR]

The role of tacit knowledge is quite important in the field of software development. So, the experience gained from one software development project can be used in other similar projects. The current paper discusses the use of techniques from Software Engineering to design and analyze a software system developed for a medium-sized manufacturing enterprise. The Structured Analysis and Design Technique (SADT) has been first used to construct a model of the problem. Then the design has been presented using Use Case Diagram, Entity Relationship Diagram and Dataflow Diagram. An interface multiplexing technique has been used to replace a number of similar interfaces to communicate with the users by a few generic ones which are dynamic in nature. The use of this technique has reduced the size of the source code by more than 40%. After developing the software, a proper analysis has been carried out in terms of software metrics. The size metrics analysis has identified the components that needed the maximum effort to develop. Alternatively, the information flow metric analysis has highlighted that the degree of cohesion and coupling of the components of the software. This analysis verified that the design of the software is cohesive and efficient. [ABSTRACT FROM AUTHOR]

In this paper, we wish to advocate that departments of computer science put emphasis on teaching programming and software engineering based on formal methods; and more emphasis on research into formal methods for the trustworthy development of software. We also wish to advocate that the concepts of domain science and domain engineering become an indispensable part of the science of informatics and of software engineering. [ABSTRACT FROM AUTHOR]

The study of critical infrastructure systems organization and behavior has drawn great attention in the recent years. This is in part due to their great influence on the ordinary life of every citizen. In this paper, we study critical infrastructures’ characteristics and propose a reference model based on the Unified Modeling Language (UML). This reference model attempts to provide suitable means for the task of modeling an infrastructure system through offering five major metamodels. We introduce each of these metamodels and explain how it is possible to integrate them into a unique representation to characterize various aspects of an infrastructure system. Based on the metamodels of UML-CI, infrastructure system knowledge bases can be built to aid the process of infrastructure system modeling, profiling, and management. [ABSTRACT FROM AUTHOR]

The purpose of the research described in this paper is to propose a framework and supporting tools that will help software companies to establish formalised methods that will be technically and socially sound with their needs. Following the framework the companies can asses and improve their existing ways of working, capture them into formalised methods and continuously enrich them based on the past development experiences. Furthermore, the formalised methods that are designed based on the suggested framework are flexible and can be automatically adjusted by the supporting tools to suite circumstances of a particular project or team. This paper describes the framework philosophy and its tool support. [ABSTRACT FROM AUTHOR]

Persistence is the term used in computer science to describe a capability to store data structures in non-volatile storage such as a file system or a relational database (Wikipedia, 2003). There is a growing need to simplify the interactions among separate systems and to build complex software systems that are made out of components with well-defined services. At the base-level of such complex systems lies a persistence framework -- a set of classes tailored to save, retrieve, update and delete objects to and from their persistence stores, such as databases and flat files. This paper presents the design, and implementation of the transparent persistence framework called PersistF. Design patterns (Gamma, Helm, Johnson, & Vlissides, 1995) have been widely accepted in the software engineering community as the recommended approach to developing software. Part of the research effort of this work included the application of well-known design patterns in order to build the framework. We present how consistent application of design patterns allowed us to build a fully working persistence framework. In order to support development of modern complex applications, some recent application development environments for different programming languages are built in with some kind of persistence framework. To use these frameworks in target applications, the developer often must go through a steep learning curve as each framework is specific in some way, but namely in respect of configuring the framework's runtime engine with enough information about the domain application. This configuration is often time consuming and error prone. Most of the existing frameworks require complicated configuration steps that are imposed onto the developer. Our aim with this work was to present a framework that will not require such complicated configuration steps and would provide its service to the target application with virtually no configuration of the framework's handling of domain classes. [ABSTRACT FROM AUTHOR]

For several years we have been engaged in the development and research of software environments for collaborative learning, for example in the recently completed CoLabs project (which we presented at the IFIP TC3 WG3.5 working conference in Budapest in 2004, see also http://matchsz.inf.elte.hu/Colabs/), also within lately defended long-range doctoral research, in which the co-author of this paper together with his undergraduate students had developed and evaluated cooperative computer activities for children aged 10 to 18. They observed children when using those environments and studied the influence of different approaches and solutions on the degree of their involvement and will to cooperate. We have also been involved in the London Knowledge Lab pilot project for developing a collaborative layered learning space travel games construction kit. Our department’s prior engagement in the development of collaborative activities also includes publishing a popular on-line journal (developed by A. Hrusecka and D. Lehotska, this on-line journal (in Slovak) can proudly boast up to 250,000 visits per month) for children, which intensively exploits on-line collaboration. This topic attracts us not only as a support for the learning process, but is a challenge for us as developers of educational programming tools as well. In our SuperLogo and Imagine environments we have always tried to provide users (ranging from children to developers) with new and powerful options to foster learning by exploring and developing. Thus we have equipped Imagine with the means for building objects and their behaviours in incremental loops, with parallel independent processes, event-driven programming and complex yet intuitive support for developing on-line environments for collaborative learning. In this paper we place our collaborative applications in the context of other related interfaces reported in literature. We use eight criteria to classify them and conclude that collaborative applications being developed by us and our students—future teachers—are distinguishable from others along two or three of those criteria: they combine in themselves typical features of Logo microworlds and inspiring support for on-line cooperation. We then analyze in detail our collaborative Imagine microworlds along four dimensions of their development. We specify means for establishing and maintaining on-line connection among any number of participants. We study tools for sending and receiving items (data, active characters with their behaviours, instructions etc.). We reflect on what can be shared by two or more participants in a collaborative activity. We examine all possible operations with common and private characters of a participant from the collaboration point of view. Our goals in this research and development are to: Most of all, however, we want to motivate the endeavour to overcome all obstacles connected with the integration of on-line cooperation into children’s learning. [ABSTRACT FROM AUTHOR]

Information Systems are situated in and are representations of some business or organizational domain. Hence, understanding the application domain is critical to the success of information systems development. To support domain understanding, the application domain is represented in conceptual models. The correctness of conceptual models can affect the development outcome and prevent costly rework during later development stages. This paper proposes a method to restrict the syntax of a modeling language to ensure that only possible configurations of a domain can be modeled, thus increasing the likelihood of creating correct domain models. The proposed method, based on domain ontologies, captures relationships among domain elements via constraints on the language metamodel, thus restricting the set of statements about the domain that can be generated with the language. In effect, this method creates domain specific modeling languages from more generic ones. The method is demonstrated using the Unified Modeling Language (UML). Specifically, it is applied to the subset of UML dealing with object behavior and its applicability is demonstrated on a specific modeling example. [ABSTRACT FROM AUTHOR]

Software architecture plays a vital role in the development (and hence maintenance) of large complex systems (containing millions of lines of code) with a long lifetime. It is therefore required that the software architecture is also maintained, i.e., sufficiently documented, clearly communicated, and explicitly controlled during its life-cycle. In our experience, these requirements cannot be met without appropriate support. Commercial-off-the-shelf support for architectural maintenance is still scarcely available, if at all, implying the need to develop appropriate proprietary means. In this paper, we reflect upon software architecture maintenance taken within three organizations within Philips that develop professional systems. We extensively describe the experience gained with introducing and embedding of architectural support in these three organizations. We focus on architectural support in the area of software architecture recovery, visualization, analysis, and verification. In our experience, the support must be carried by a number of pillars of software development, and all of these pillars have to go through a change process to ensure sustainable embedding. Managing these changes requires several key roles to be fulfilled in the organization: a champion, a company angel, a change agent, and a target. We call our reflection model C-POSH, which is an acronym for Change management of the four identified pillars of software development: Process, Organization, Software development environment, and Humans. Our experiences will be presented in terms of the C-POSH model. Copyright © 2005 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

This paper presents Reconciliation+, a method which identifies overlaps between models of software systems behaviour expressed as UML object interaction diagrams (i.e., sequence and/or collaboration diagrams), checks whether the overlapping elements of these models satisfy specific consistency rules and, in cases where they violate these rules, guides software designers in handling the detected inconsistencies. The method detects overlaps between object interaction diagrams by using a probabilistic message matching algorithm that has been developed for this purpose. The guidance to software designers on when to check for inconsistencies and how to deal with them is delivered by enacting a built-in process model that specifies the consistency rules that can be checked against overlapping models and different ways of handling violations of these rules. Reconciliation+ is supported by a toolkit. It has also been evaluated in a case study. This case study has produced positive results which are discussed in the paper. [ABSTRACT FROM AUTHOR]

Model Driven Architecture (MDA) is an approach to application modeling and generation that has received a lot of attention in recent months. Championed by the Object Management Group (OMG), many organizations are now looking at the ideas of MDA as a way to organize and manage their application solutions, tool vendors are explicitly referring to their capabilities in terms of “MDA compliance”, and the MDA lexicon of platform-specific and platform-independent models is now widely referenced in the industry.In spite of this interest and market support, there is little clear guidance on what MDA means, where we are in its evolution, what is possible with today’s technology, and how to take advantage of it in practice. This paper addresses that need by providing an analysis of how modeling is used in industry today, the relevance of MDA to today’s systems, a classification of MDA tooling support, and examples of its use. The paper concludes with a set of recommendations for how MDA can be successful in practice. [ABSTRACT FROM AUTHOR]

Software development for computer-supported cooperative work (CSCW) is a notoriously difficult task, involving often concurrent processes which are bound up with rigid timing constraints. To cope effectively with this difficulty, we propose in this paper the use of abstract finite-state models. The utility of these models is illustrated by encoding a CSCW system that we have built into finite-state automata, specifying in them a number of desired properties with temporal logic, and verifying these properties with model checking. By incorporating timing constraints into this process, we also gain insight into the usability of our system in real cooperative scenarios. [ABSTRACT FROM AUTHOR]

This paper discusses Extreme Programming (XP), a relatively new and increasingly popular `user-centred' software design approach. Extreme Programming proposes that collaborative software development should be centred on the practices of programming. That proposal contrasts strongly with more heavily instrumented, formalised and centrally managed software engineering methodologies. The paper maps the interactions of an Extreme Programming team involved in building a commercial organisational knowledge management system. Using ethnographic techniques, it analyses how this particular style of software development developed in a given locality, and how it uniquely hybridised documents, conversations, software tools and office layout in that locality. It examines some of the many artifices, devices, techniques and talk that come together as a complicated contemporary software system is produced. It argues that XP's emphasis on programming as the core activity and governing metaphor can only be understood in relation to competing overtly formal software engineering approaches and the organisational framing of software development. XP, it suggests, gains traction by re-embodying the habits of programming as a collective practice. [ABSTRACT FROM AUTHOR]

To assess the reliability of software products, the differences between the testing phase and the operational phase must be clearly distinguished. In contrast to the former that makes assessments based only on the statistical properties of the fault detection mechanism observed in the testing process, the latter must be executed by predicting the differences between the environment in the testing phase (effort, test method, and so on) and the software operational environment such as the frequency of use. Previously, many reliability assessment methods for software products in the operational phase have been proposed. However, none have adequately modeled the software operational environments without conflicts. The general methodologies in this field have still not been established. In this paper, we propose a dynamic model to represent the phenomenon of software reliability growth in the operational phase by applying the concept of accelerated life testing of hardware. In addition, we investigate the effectiveness of our model by using both the fault detection time data obtained in the actual software testing process and the error occurrence time data observed in the operational phase. © 2001 Scripta Technica, Electron Comm Jpn Pt 3, 84(8): 25–33, 2001 [ABSTRACT FROM AUTHOR]

Computer science is a predominantly male field of study. Women face barriers while trying to insert themselves in the study of computer science. Those barriers extend to when women are exposed to the professional area of computer science. Despite decades of social fights for gender equity in Science, Technology, Engineering, and Mathematics (STEM) education and in computer science in general, few women participate in computer science, and some of the reasons include gender bias and lack of support for women when choosing a computer science career. Open source software development has been increasingly used by companies seeking the competitive advantages gained by team diversity. This diversification of the characteristics of team members includes, for example, the age of the participants, the level of experience, education and knowledge in the area, and their gender. In open source software projects women are underrepresented and a series of biases are involved in their participation. This paper conducts a systematic literature review with the objective of finding factors that could assist in increasing women's interest in contributing to open source communities and software development projects. The main contributions of this paper are: (i) identification of factors that cause women's lack of interest (engagement), (ii) possible solutions to increase the engagement of this public, (iii) to outline the profile of professional women who are participating in open source software projects and software development projects. The main findings of this research reveal that women are underrepresented in software development projects and in open source software projects. They represent less than 10% of the total developers and the main causes of this underrepresentation may be associated with their workplace conditions, which reflect male gender bias. [ABSTRACT FROM AUTHOR]

This paper discuss the results of two case studies from a technical perspective, concentrating on the evolution of software assets in two Swedish organizations that have employed a product-line architecture approach for several years. This paper describes and analyses the commonalities and differences of these two cases, emphasising categories of the evolution of the requirements, of the software architecture and of the software components. This paper concludes with three types of lessons learned about evolution In software product lines: three evolution categories are predominant, three other categories are less significant but still common, and seven guidelines for software product-line evolution emerge. [ABSTRACT FROM AUTHOR]

Programmes in “Software Engineering” have become a source of contention in many universities. Some Computer Science departments, many of which have used that phrase to describe individual courses for decades, claim software engineering as part of their discipline. However, Engineering faculties claim “Software Engineering” as a new speciality in the family of engineering disciplines. This paper discusses the differences between traditional computer science programmes and most engineering programmes and argues that we need programmes that follow the traditional engineering approach to professional education and educate engineers whose speciality within engineering is software construction. One such programme is described. [ABSTRACT FROM AUTHOR]

This paper describes how we have modified a software engineering stream within a computer science course to include broader concepts of systems engineering. We justify this inclusion by showing how many reported problems with large systems are not just software problems but relate to system issues such as hardware and operational processes. We describe what we mean by ‘systems engineering’ and go on to discuss the particular course structure which we have developed. We explain, in some detail, the contents of two specific systems engineering courses (Software Intensive Systems Engineering and Critical Systems Engineering) and discuss the problems and challenges we have faced in making these changes. In the appendix, we provide details of the case studies which are used as linking themes in our courses. [ABSTRACT FROM AUTHOR]

This paper describes the development of an undergraduate degree programme in software engineering over the ten year period from 1988 to 1998. Particular emphasis is given to the fundamental principles that have been established to guide the creation and evolution of this programme during this period, and to ensure that it has been distinctively a course in software engineering rather than in any other branch of computing. To this end, the fundamental engineering characteristics of the programme are compared with those of undergraduate courses in other branches of engineering. Desirable future developments in this programme are then discussed, and finally the different principles identified in the paper are evaluated. [ABSTRACT FROM AUTHOR]

Software engineering education has a 30-year history. It is a story of academics struggling to fulfill industry needs with almost no support from computer science curriculum designers. It is a story of industry finally winning over some of academia to teach software engineering rather than vanilla computer science. It is a story of a discipline still incomplete, but having made great strides in the last decade. This paper discusses the succeeding eras of software engineering education, from lone teachers to master's curricula to undergraduate degree programs. Even though the maturity of the discipline is as yet unattained, it will achieve adult status through practice, not by waiting for academia to glacially catch up. [ABSTRACT FROM AUTHOR]