SPECIAL ISSUE ON
|
|
Publication Details: Please refer to the Journal's homepage for ordering information: We thank all members of the scientific and publishing staff of this Journal for making this Special Issue possible and for their continuous support in the whole process!
Use-Case Components for Interactive Information Systems Eliezer Kantorowitz Computer Science Dept., Technion, Israel Alexander Lyakas (Computer Science Dept., Technion, Israel) Abstract: Specification-oriented components (SOC) are designed to facilitate the implementation of a system directly from its specifications. An earlier study has shown cases, in which SOC's enabled information systems to be implemented with considerably less code, than when implemented with components designed by a typical object-oriented approach. This study goes a further step by considering the essence of an information system to be the flow and processing of data. The components based on this abstraction attempt to hide code that is not implementing data flow or data processing. Based on this approach, an experimental framework called WebSI has been developed. WebSI components hide the code for the construction of the user interface (UI), the database access code and the Web-related code. WebSI was designed to facilitate the manual translation of English language use-case specifications into Java code. WebSI enabled the construction of information systems with a modest amount of code. The similarity between the WebSI-based Java code and the English language use-case specifications facilitated verifying that the code implements the specifications correctly. The automatically produced UI's were relatively easy to learn and to use. The modification of WebSI-based legacy code was facilitated by the high level of the code and its use-case structure, but remained a labor-intensive task.
Date of Submission: 28 November 2003
Extending component-based design with hardware components Péter Arató (Budapest University of Technology and Economics, Hungary) Zoltán Ádám Mann (Budapest University of Technology and Economics, Hungary) András Orbán (Budapest University of Technology and Economics, Hungary) Abstract: In order to cope with the increasing complexity of system design, component-based software engineering advocates the reuse and adaptation of existing software components. However, many applications -- particularly embedded systems -- consist of not only software, but also hardware components. Thus, component-based design should be extended to systems with both hardware and software components. Such an extension is not without challenges though. The extended methodology has to consider hard constraints on performance as well as different cost factors. Also, the dissimilarities between hardware and software (such as level of abstraction, communication primitives etc.) have to be resolved. In this paper, the authors propose such an extended component-based design methodology to include hardware components as well. This methodology allows the designer to work at a very high level of abstraction, where the focus is on functionality only. Non-functional constraints are specified in a declarative manner, and the mapping of components to hardware or software is determined automatically based on those constraints in the so-called hardware/software partitioning step. Moreover, a tool is presented supporting the new design methodology. Beside automating the partitioning process, this tool also checks the consistency between hardware and software implementations of a component. The authors also present a case study to demonstrate the applicability of the outlined concepts.
Date of Submission: 28 November 2003
Supporting Software Composition at the Programming-Language Level Peter H. Froehlich (Department of Computer Science and Engineering University of California, Riverside, USA) Andreas Gal (School of Information and Computer Science University of California, Irvine, USA) Michael Franz (School of Information and Computer Science University of California, Irvine, USA) Abstract: We are in the midst of a paradigm shift toward component-oriented software development, and significant progress has been made in understanding and harnessing this new paradigm. Oddly enough, however, the new paradigm does not currently extend to the level at which components themselves are constructed. While we have composition architectures and languages that describe how systems are put together out of atomic program parts, the parts themselves are still constructed based on a previous paradigm: object-oriented programming. We argue that this mismatch impedes the progress of compositional software design: many of the assumptions that underly object-oriented languages simply do not apply in the open and dynamic contexts of component software environments. What, then, would a programming language that supported component-oriented programming at the smallest granularity look like? Lagoona, our project to develop such a language, tries to answer this question. This paper motivates the key concepts behind Lagoona and briefly describes their realization (using Lagoona itself as the implementation language) in the context of Microsoft's .NET environment.
Date of Submission: 31 October 2003
A Form-based Metamodel for Software Composition Markus Lumpe (Dept. of Computer Science, Iowa State University, USA) Jean-Guy Schneider (School of Information Technology Swinburne University of Technology, Australia) Abstract: In recent years considerable progress has been made to facilitate the specification and implementation of software components. However, it is far less clear what kind of language support is needed to enable a flexible and reliable software composition approach. Object-oriented programming languages seem to already offer some reasonable support for component-based programming (e.g., encapsulation of state and behavior, inheritance, late binding). Unfortunately, these languages typically provide only a fixed and restricted set of mechanisms for constructing and composing compositional abstractions. In this article, we will present a generic meta-level framework for modeling both object- and component-oriented programming abstractions. In this framework, various features, which are typically merged in traditional object-oriented programming languages, are all replaced by a single concept: the composition of forms. Forms are first-class, immutable, extensible records that allow for the specification of compositional abstractions in a language-neutral and robust way. Thus, using the meta-level framework, we can define a compositional model that provides the means both to bridge between different object models and to incorporate existing software artifacts into a unified composition system.
Date of Submission: 09 November 2003
Architectural Styles for Active Documents Uwe Assmann (RISE, PELAB, Linköpings Universitet, Sweden and Fakultät für Informatik, TU Dresden, Germany) Abstract: This paper proposes several novel architectural styles for active documents. Active documents are documents that do not only contain data, but also servlets, applets, expressions in spreadsheet languages, and other forms of software. To grasp the different forms of architectures, several novel concepts are defined. Invasive document composition is a type-safe form of template expansion and extension; transconsistency is a form of transclusion for architectures; and staged architectures provide a form of staged programming on the architectural level. With these concepts, it is possible to explain the architectures of many document processing applications for web and office, and we define the architectural styles of wizard-parameterized, script-parameterized, transconsistent, stream-based, and staged active documents. Finally, we give a hypothesis of active document composition: it consists of four elements viz., explicit architecture, invasiveness, transconsistency, and staging. Based on this hypothesis, many applications in web engineering and document processing get a common background, can be compared and simplified.
Date of Submission: 24 November 2003
A Technique for Automatic Component Extraction from Object-Oriented Programs by Refactoring Hironori Washizaki (National Institute of Informatics, Japan) Yoshiaki Fukazawa (Waseda University, Japan) Abstract: Component-based software development (CBD) is based on building software systems from previously-existing software components. In CBD, reuse of common parts in component form can reduce the development cost of new systems, and reduce the maintenance cost associate with the support of these systems. However, existing programs have usually been built using another paradigm, such as the Object-Oriented (OO) paradigm. OO programs cannot be reused rapidly or effectively in the CBD paradigm even if they contain reusable functions. In this paper, we propose a technique for extracting components from existing OO programs by our new refactoring "Extract Component". Our technique of refactoring can identify and extract reusable components composed of classes from OO programs, and modify the surrounding parts of extracted components in original programs. We have developed a system that performs our refactoring automatically and extracts JavaBeans components from Java programs. As a result of evaluation experiments, it is found that our system is useful for extracting reusable components along with usage examples from Java programs.
Date of Submission: 29 October 2003
Hierarchical Composition of Industrial Components Ursula Scheben (FernUniversitaet Hagen, Germany) Abstract: In this paper we focus on hierarchical composition of instances of arbitrary industrial component models yielding new (compound) components with specified capabilities and requirements which can themselves be composed to yield higher level components. For this purpose special component interfaces and component implementations are defined which ensure a smooth integration of industrial components. The component implementations of compound components enable a late binding by referring to enclosed component instances only by their component interfaces. But also explicit bindings between component interfaces and component implementations can be defined. A type system for components is introduced enabling a formal definition of exchangeability and interoperability of components. Using this type system, tools are able to decide, which components may be exchanged by others and which components fit together. They can also support the creation of new components from existing ones by checking a new assembly for consistency.
Date of Submission: 20 November 2003
Self Cerfication and Trust in Component Procurement Hans-Gerhard Gross (Fraunhofer Institute for Experimental Software Engineering, Germany Matteo Melideo (Engineering Ingegneria Informatica S.p.A, Italy) Alberto Sillitti (Free University of Bolzano, Bolzano, Italy) Abstract: Component-based software engineering is typically perceived as application development in which existing individual software components are assembled and integrated in order to make up the final product. The main recent technological advances in this field are therefore mainly focusing on the integration step. This encompasses the syntactic and semantic mapping between components, the development of component wrappers and adapters, and the validation of all pair-wise component interactions. Additionally, prior to integration, components have to be located on a component market place, evaluated for their fitness for the purpose, and selected according to non-functional requirements. These activities are typically referred to as component procurement. Component brokerage platforms provide the support for these early phases of component assembly, and they are indispensable for strengthening the software component market. Although such platforms are good at the provision of components, they are not so good at their certification. This article proposes the combination of two contrasting technologies, component-brokerage at one end of the component technology spectrum, and built-in contract testing at its other end, that combined, may alleviate the efforts involved in component certification. This is achieved through the access mechanisms that built-in contract testing provides for components, and additional tester components through which customers can themselves assess the quality of a candidate component that is coming from a broker. Every such an extended component is added to the certification according to well-defined standards, that are provided by a third party on behalf of the supplier.
Date of Submission: 23 October 2003
Achieving Seamless Component Composition Through Scenario-Based Deep Adaptation And Generation Xiaodong Liu (School of Computing, Napier University, Edinburgh, UK) Beihu Wang (School of Computing, Napier University, Edinburgh, UK) Jon Kerridge (School of Computing, Napier University, Edinburgh, UK) Abstract: Mismatches between pre-qualified existing components and the particular reuse context in applications have been a major factor hindering component reusability and successful composition. Although component adaptation has acted as a key solution of eliminating these mismatches, deep adaptation is often either impossible or incurring heavy overheads in the components. This paper proposes an approach, namely Scenario-based dynamic component Adaptation and GenerAtion (SAGA), to achieve deep adaptation with little code overhead through XML-based component specification, interrelated adaptation scenarios and corresponding component adaptation and generation.
Date of Submission: 29 October 2003
Composition of Software Artifacts Modelled Using Coloured Petri Nets Leandro Dias da Silva (Department of Electrical Engineering, Federal University of Campina Grande, Brasil) Angelo Perkusich (Department of Electrical Engineering, Federal University of Campina Grande, Brasil) Abstract: In this work it is introduced a new formal model for software components supporting behavioral interpretability based on temporal logic, Petri nets, model checking, and an assume-guarantee strategy to specify and reason about the composition of concurrent component systems. The formal specification and verification strategies, methods and techniques presented in this work contribute to the development of more dependable component-based software systems in a modular way. An approach based on two complementary formalisms, Hierachical Coloured Petri Nets (HCPN) and temporal logic is introduced. HCPNs are used to visualize the structure and model the behavior of software architectures and components and temporal logic is used to specify the required properties of software architectures and component interfaces.
Date of Submission: 30 October 2003
Software Composition and Verification for Sensor Networks Peter Völgyesi (Hungarian Academy of Sciences, Budapest University of Technology and Economics, Hungary) Miklos Maróti (Vanderbilt University, Nashville, USA) Sebestyen Dóra (Vanderbilt University, Nashville, USA) Esteban Osses (Vanderbilt University, Nashville, USA) Akos Lédeczi (Vanderbilt University, Nashville, USA) Abstract: Component-based design has become a necessity for networked embedded systems where hardware platforms come in a great variety and evolve extremely rapidly. Operating system components and higher level middleware services call for modular software construction along clear interfaces. The way we describe these interfaces and process the captured information is of crucial importance to exploit the benefits of component-based design. In this paper we present a model based approach to the development of embedded applications with a special emphasis on interfacespecification. The proposed formalism captures the temporal and type aspects of interfaces and supports composition and verification of components. Along with the formal definition of the proposed interface language and component compatibilityrules, we present a modeling environment targeting TinyOS, a representative embedded operating system. Two prototype tools are also described that check the composability of components based on their interface models and verify that the implementation of a component matches its formal model, respectively.
Date of Submission: 06 November 2003
Coverage Testing of Java Programs and Components Auri Vincenzi (Centro Universitario Euripides de Marilia - UNIVEM, Brazil) Jose Maldonado (Instituto de Ciencias Matematicas e de Computacao - ICMC/USP, Brazil) Eric Wong (University of Texas at Dallas - UTD, USA) Marcio Delamaro (Centro Universitario Euripides de Marilia - UNIVEM, Brazil) Abstract: Although software testing is a crucial activity in the software development process, only recently have more sound and consistent testing tools become available for testing Java programs and their components. These tools support mostly functional and control-flow based structural criteria. In this paper we explore control-flow and data-flow based coverage criteria to support the testing of java programs and/or components. We also describe a testing tool, named JaBUTi, which can be used by both the component developer and the component user to test Java-based components and/or systems. To achieve this goal, the tool works at the bytecode level such that no source code is required during the testing activity. We illustrate these ideas and concepts with an example extracted from the literature.
Date of Submission: 8 November 2003
Sequences as a Basis for Pattern Language Composition Ronald Porter (School of Informatics and Engineering Flinders University of South Australia, Australia) James O. Coplien (Vrije Universiteit Brussel, Belgium and North Central College, Naperville, USA) Tiffany Winn (School of Informatics and Engineering, Flinders University of South Australia, Australia) Abstract: Pattern Languages have begun to appear and mature as a presentation of the structures and processes that support the building of complex software systems. A pattern language describes how to compose structures in a particular domain such as telecommunications, client-server architecture, or object-oriented programming, to achieve system-level architectures that are greater than the sum of their parts. A problem lurks on the horizon: How do you compose patterns from multiple domains---from multiple pattern languages---in a single system? For example, today there is nothing other than an ad-hoc approach to combining the pattern languages for telecommunications and for object-oriented design to build object-oriented telecommunications systems from the respective pattern languages. To understand the solution to this dilemma, it pays to examine sequences: an important aspect of pattern application that is often overlooked. Sequences are the loci of concern about interleaving patterns, whether from a single pattern language or multiple pattern languages. Sequences are critical because pattern languages represent long-term archives of the rhythms of critical, recurring sequences.
Date of Submission: 12 November 2003
|
