Software development and continual change: A programmers attitude problem.

Software fonns around a requirement. Defining this requirement is often regarded as the hardest part of software engineering. The requirement however has an additional complexity as, once defined, it will change with time. This change of requirement can come either from the user, or from the rapid advances in 'computer' technology. How then can software succeed to continue to remain 'current' both in tenns of requirements and technology in this forever changing environment? This thesis examines the issues surrounding 'change' as applied to software and software engineering. Changing requirements are often deemed a 'curse' placed upon software engineers. It has been suggested, however, that the problems associated with change exist only in the attitude of software engineers. This is perhaps understandable considering the training methods and tools available to supposedly 'help' them. The evidence shows that quality of management and experience of personnel involved in development contribute more significantly to the success of a development project than any technical aspect. This unfortunately means that the process is highly susceptible to staff turnover which, if uncontrolled, can lead to pending disaster for the users. This suggests a 'better' system would be developed if 'experience' was maintained at a process level, rather that at an individual level. Conventional methods of software engineering are based upon a defined set of requirements which are detennined at the beginning of the software process. This thesis presents an alternative paradigm which requires only a minimal set of requirements at the outset and actively encourages changes and additional requirements, even with a mature software product. The basis of this alternative approach is the fonn of the 'requirements specification' and the capturing and re-use of the 'experience' maintained by the software process itself

Focus Issue on Legacy Information Systems and Business Process Change: Migrating Large-Scale Legacy Systems to Component-Based and Object Technology: The Evolution of a Pattern Language

The process of developing large-scale business critical software systems must boost the productivity both of the users and the developers of software, while at the same time responding flexibly to changing business requirements in the face of sharpening competition. Historically, these two forces were viewed as mutually hostile. Component-based software development using object technology promises a way of mediating the apparent contradiction. This paper presents a successful new approach which focuses primarily on the architecture of the software system to migrate an existing system to a new form. Best practice is captured by software patterns that address not only the design, but also the process and organizational issues. The approach was developed through four completed, successful live projects in different business and technical areas. It resulted in a still-evolving pattern language called ADAPTOR (Architecture-Driven and Pattern-based Techniques for Object Re-engineering). This article outlines the approach that underlies ADAPTOR. It challenges popular notions of legacy systems by emphasizing business requirements. Architectural approaches to migration are then contrasted with traditional reverse engineering approaches, including the weakness of reverse engineering in the face of paradigm shifts. The evolution of the ADAPTOR pattern language is outlined with a brief history of the projects from which the patterns were abstracted

Safety component-based approach and its application to ERTMS/ETCS on-board train control system

International audienceSafety-critical software is becoming more and more complex and at the same time it operates in frequently changing environments on which it reacts by reconfiguring its architecture. Thus, an appropriate modelling approach is needed to reduce the complexity of designing and to enable the verification of dynamic reconfiguration behaviour before the deployment at runtime. The paradigm of software component-based engineering provides an essential support for this. However, composing software from many reconfigurable components can lead to a huge number of possible compositional configurations difficult to handle at design time. Moreover, analysing all possible sequences of reconfiguration, including failure situations, is far beyond feasibility without an appropriate abstraction and granularity levels. In this paper, we propose a hierarchical component-based design approach to reduce the complexity of designing and to analyse the dynamic reconfiguration behaviour. We illustrate our approach with a case study derived from ERTMS/ETCS level 2

A systematic comparison of roundtrip software engineering approaches

Model-based software engineering contemplates several software development approaches in which models play an important role. One such approach is round-trip engineering. Very briefly, round-trip engineering is code generation from models, and models are updated whenever a code change occurs. The objective of this dissertation is to benchmark the comparative analysis of the round-trip engineering capability of the UML, Papyrus, Modelio and Visual Paradigm modeling tools. In more detailed terms, the work will focus on evaluating tools to automatically or semi-automatically support round-trip engineering processes for each selected diagram. Collaterally, this dissertation will allow us to gain insight into the current round-trip engineering landscape, establishing the state-of-the-art UML modeling tool support for this approach. Qualitative and quantitative analysis of the round-trip engineering capabilities of the tools show that the Papyrus, Modeling and Visual Paradigm tools yielded satisfactory results by applying the Reverse and Forward Engineering scenarios without changing the models and codes but applying the Round-trip engineering scenario with changes in model and code presented results with some gaps in model and code coherence. It was concluded that they arose because the semantic definition of the models was done informally. The conclusions drawn throughout the dissertation will answer the questions: How effective are current code generation tools for documenting application evolution? Where will it support the decision made? objectives and will support the recommendations of the best tools that address the round-trip engineering method.A engenharia de software baseada em modelo contempla várias abordagens de desenvolvimento de software nas quais os modelos desempenham um papel importante. Uma dessas abordagens é a Round-trip engineering. Muito brevemente, a Round-trip engineering é a geração de código a partir de modelos, e os modelos são atualizado sempre que ocorre uma alteração no código. O objetivo desta dissertação é a realização de um benchmarking da análise comparativa da capacidade de Round-trip engineering das ferramentas de modelação UML, Papyrus, Modelio e Visual Paradigm. Em termos mais detalhados, o trabalho se concentrará na avaliação de ferramentas para dar suporte automático ou semiautomático a processos de Round-trip engineering (engenharia direta e engenharia reversa) para cada diagrama selecionado. Colateralmente, esta dissertação permitirá alcançar uma visão do panorama atual da Round-trip engineering, estabelecendo o estado da arte do suporte de ferramentas de modelação em UML à dita abordagem. A analise qualitativa e quantitativamente da capacidade de Round-trip engineering das ferramentas mostro que, as ferramentas Papiro, Modelagem e Paradigma Visual apresentaram resultados satisfatórios aplicando os cenários de Reverse e Forward Engineering sem alterar os modelos e códigos e com alterações, mas aplicando o cenário Round-trip engineering com alterações nos modelo e código apresentaram resultados com algumas lacunas nomeadamente na coerência dos modelos e código. Concluiu-se que as mesmas surgiram por causa da definição semântica dos modelos ser feita de forma informal. As conclusões tiradas ao longo do trabalho respondera as perguntas: Qual a eficácia das ferramentas atuais de geração de código para documentar a evolução dos aplicativos? Onde apoiará a decisão tomada? que foram definidas nos objetivos e apoiarão as recomendações das melhores ferramentas que aborda o método Round-trip engineering

Acute stress response for self-optimizing mechatronic systems

Self-optimizing mechatronic systems react autonomously and flexibly to changing conditions. They are capable of learning and optimize their behavior throughout their life cycle. The paradigm of self-optimization is originally inspired by the behavior of biological systems. The key to the successful development of self-optimizing systems is a conceptual design process that precisely describes the desired system behavior. In the area of mechanical engineering, active principles based on physical effects such as friction or lever are widely used to concretize the construction structure and the behavior. The same approach can be found in the domain of software-engineering with software patterns such as the broker-pattern or the strategy pattern. However there is no appropriate design schema for the development of intelligent mechatronic systems covering the needs to fulfill the paradigm of self-optimization. This article proposes such a schema called Active Patterns for Self-Optimization. It is shown how a catalogue of active patterns can be derived from a set of four basic active patterns. This design approach is validated for a networked mechatronic system in a multiagent setting where the behavior is implemented according to a biologically inspired technique – the neuro-fuzzy learning method.1st IFIP International Conference on Biologically Inspired Cooperative Computing - Mechatronics and Computer ClustersRed de Universidades con Carreras en Informática (RedUNCI

Active patterns for self-optimization : Schemes for the design of intelligent mechatronic systems

Self-optimizing mechatronic systems react autonomously and flexibly to changing conditions. They are capable of learning and optimize their behavior throughout their life cycle. The paradigm of self-optimization is originally inspired by the behavior of biological systems. The key to the successful development of self-optimizing systems is a conceptual design process that precisely describes the desired system behavior. In the area of mechanical engineering, active principles based on physical effects such as friction or lever are widely used to concretize the construction structure and the behavior. The same approach can be found in the domain of software-engineering with software patterns such as the broker-pattern or the strategy pattern. However there is no appropriate design schema for the development of intelligent mechatronic systems covering the needs to fulfill the paradigm of self-optimization. This article proposes such a schema called Active Patterns for Self-Optimization. It is shown how a catalogue of active patterns can be derived from a set of four basic active patterns. This design approach is validated for a networked mechatronic system in a multiagent setting where the behavior is implemented according to a biologically inspired technique – the neuro-fuzzy learning method.1st IFIP International Conference on Biologically Inspired Cooperative Computing - Mechatronics and Computer ClustersRed de Universidades con Carreras en Informática (RedUNCI

Software Engineering for Development: A Position Statement

There is little work on targeted methodologies to develop IT applications and content in a developing world environment. This paper argues for a methodology called Socially Aware Software Engineering that we are busy formulating based on firsthand experience building Information and Communication Technology solutions. Our method is based on a classical user-centred approach from Human Computer Interaction combined with aspects of Participatory Design and cyclical software engineering practises. These approaches are wrapped into an iterative Action Research paradigm in order to directly include the community-based users of our systems. I conclude with suggestions on changing the nature of tertiary curricula in developing countries in a way that integrates this socially aware software engineering methodology