Designers often seek modular architectures for complex systems so that their systems better accommodate expected changes, have parts that can be developed and evolved without further coordination, and to ease the understanding of complex designs through abstraction of details hidden within modules. However, current design modeling techniques do not effectively support design modularization and evolution analysis. In this paper, we present a framework to enable automatic and quantifiable software modularization and evolution analyses for high-level design abstractions. The framework contributes a model to substantiate the concept of information hiding as a measurable criterion for software designs, an algorithm to extract the dependence structure of an abstract design, and an approach to quantitatively analyzing the changeability of a design. We have imported existing engineering techniques and economic analysis into software, and made these abilities formalized and automated. We illustrate and demonstrate the potential utility of our modeling and analysis techniques by modeling and analyzing several design examples.

The current proposal for activity diagrams in UML 2.0 allows for very complex graphs, reflecting the numerous interdependencies among the several actions and resources. This paper proposes a graphical composition operation supporting the addition of crosscutting requirements in activity diagrams through node fusion, addition, and subtraction. The operation has a highly readable and intuitive graphical representation and allows simple traceability and coupling. It is illustrated by a set of examples related to the inclusion of mutual exclusion and fair execution across several activity nodes.

Abstract. The separation of concerns is a fundamental principle in software engineering. Crosscutting concerns are concerns that do not align with hierarchical and block decomposition supported by mainstream programming languages. In the past, crosscutting concerns have been studied mainly in the context of object orientation. Feature orientation is a novel programming paradigm that supports the (de)composition of crosscutting concerns in a system with a hierarchical block structure. In two case studies we explore the problem of crosscutting concerns in functional programming and propose two solutions based on feature orientation. 1

Software product lines (SPLs) are used to create tailor-made software products by managing and composing reusable assets. Generating a software product from the assets of an SPL is possible statically before runtime or dynamically at load-time or runtime. Both approaches have benefits and drawbacks with respect to composition flexibility, performance, and resource consumption. Which type of composition is preferable should be decided by taking the application scenario into account. Current tools and languages, however, force a programmer to decide between static and dynamic composition during development. In this paper, we present an approach that employs code generation to support static and dynamic composition of features of a single code base. We offer an implementation on top of FeatureC++, an extension of the C++ programming language that supports software composition based on features. To simplify dynamic composition and to avoid creation of invalid products we furthermore provide means to (1) validate the correctness of a composition at runtime, (2) automatically instantiate SPLs in case of stand-alone applications, and (3) automatically apply interaction code of crosscutting concerns.

Abstract not found

Heuristics have long been recognised as a way to tackle problems which are intractable because of their size or complexity. They have been used in software engineering for purposes such as identification of favourable regions of design space. Some heuristics in software engineering can be expressed in high-level abstract terms while others are more specific. Heuristics tend to be couched in terms which make them hard to automate. In our previous work we have developed robust semantic models of software in order to support the computation of metrics and the construction of visualisations which allow their interpretation by developers. In this paper, we show how software engineering heuristics can be supported by a semantic model infrastructure. Examples from our current work illustrate the value of combining the rigour of a semantic model with the human mental models associated with heuristics.

We were motivated to undertake the research we describe here by a conversation with two practicing software engineers, who described a dilemma they faced at work. They worked for small company that earned revenues by delivering

The software industry is currently in the middle of a paradigm shift. Applications are increasingly written for the World Wide Web rather than for any specific type of an operating system, computer or device. Unfortunately, the technologies used for web application development today violate well-known software engineering principles. Furthermore,they have reintroduced problems that had already been eliminated years ago in the aftermath of the “spaghetti code wars ” of the 1970s. In this paper, we investigate web application development from the viewpoint of established software engineering principles. We argue that current web technologies are inadequate in supporting many of these principles. However, we also argue that there is no fundamental reason for web applications to be any worse than conventional applications in any of these areas. Rather, the current inadequacies are just an accidental consequence of the poor conceptual and technological foundation of the web development technologies today.

Abstract: Nowadays, advanced E-Learning systems are generally pedagogy-aware. Commonly, these systems include facilities for defining so-called learning scenarios that reflect sophisticated pedagogical approaches such as collaborative writing or project-oriented learning. To support different learning activities from such scenarios the technological infrastructure of these systems must be appropriately adjusted and configured. Usually, this configuration process is laced with a number of difficulties. Most of these difficulties are caused by the fact that scenario capturing is achieved through informal user-developer dialogues. Typically, the result of such informal dialogues contains inconsistent and incomplete information because of misunderstandings and the complexity of the interactions within a scenario. Consequently, the configuration of the system is suboptimal and a number of iterations are required in order to achieve better results. In this paper an approach to improve this situation is presented. This approach is based on a general formal representation model for describing learning scenarios. A particular formal description of a concrete learning scenario is obtained through a user dialogue with a wizard tool. At the next step, this formal description might be automatically processed to facilitate configuration process. The paper is concluded with some experiences gained by applying this approach in two E-Learning projects. Keywords: E-Learning, E-Learning system, learning scenario, formal representation, configuration

J-Orchestra is a system that enhances centralized Java programs with distribution capabilities. Operating at the bytecode level, J-Orchestra transforms a centralized Java program (i.e., running on a single Java Virtual Machine (JVM)) into a distributed one (i.e., running across multiple JVMs). This transformation effectively separates distribution concerns from the core functionality of a program. J-Orchestra follows a semi-automatic transformation process. Through a GUI, the user selects program elements (at class granularity) and assigns them to network locations. Based on the user’s input, the J-Orchestra backend automatically partitions the program through compiler-level techniques, without changes to the JVM or to the Java Runtime Environment (JRE) classes. By means of bytecode engineering and code generation, J-Orchestra substitutes method calls with remote method calls, direct object references with proxy references, etc. It also translates Java language features (e.g., static methods and fields, inheritance, inner classes, new object construction, etc.) for efficient distributed execution. We detail the main technical issues that J-Orchestra addresses, including its mechanism for program transformation in the presence of unmodifiable code (e.g., in JRE classes) and the translation of concurrency and synchronization constructs to work correctly over the network. We further discuss a case study of transforming a large, commercial, third-party application for efficient execution in a client server environment and outline the architectural characteristics of centralized programs that are amenable to automated distribution with J-Orchestra.