Component-based software is finally taking off in a big way and component-based application generators have been championed because they can be used to shorten a system¡¦s development cycle and therefore lower its development costs. Component-based application generators are standardardized building blocks that can be used to assemble, rather that develop, information systems (IS). This paper presents a component-based application generator in the restaurant food ordering setting and a requirement modeling methodology for IS construction based on the generator presented. A prototype was assembled using the generator and methodology presented to illustrate the concepts and application. With this approach, system developers or end users can more easily build, modify and maintain their applications.

Self-adaptivity, characterized by the ability to dynamically adjust behavior at runtime, is a growing trend in the evolution of modern embedded systems. While self-adaptive systems tend to be flexible and autonomous, self-adaptivity may inevitably complicate software design, test and analysis. A strategy for taming the growing software complexity of self-adaptive systems is to partition system behaviors into different operational modes specified at design time. Such a multi-mode system can change behavior by switching between modes at runtime under certain circumstances. Multi-mode systems can benefit from a complementary approach to the software development of complex systems: Component-Based Software Engineering (CBSE), which fosters reuse of independently developed software components. However, the state-of-the-art component-based development of multi-mode systems does not take full advantage of CBSE, as reuse of modes at component level is barely addressed. Modes are often treated as system properties, while mode switches are handled by a global mode manager. This centralized mode management entails global information of all components, whereas the global information may be inaccessible in component-based systems. Another potential problem is that a single mode manager does not scale well, particularly at design time,  for a large number of components and modes.   In this thesis we propose a distributed solution to the component-based development of multi-mode systems, aiming for a more efficient and scalable mode management. Our goal is to fully incorporate modes in software component reuse, supporting reuse of multi-mode components, i.e., components able to run in multiple modes. We have developed a generic framework, the Mode-Switch Logic (MSL), which not only supports reuse of multi-mode components but also provides runtime mechanisms for handling mode switch. MSL includes three fundamental elements: (1) a mode-aware component model with the formal specification of reusable multi-mode software components; (2) a mode mapping mechanism for the seamless composition of multi-mode components; and (3) a mode-switch runtime mechanism which is executed by each component in isolation from its functional execution and coordinates the mode switches of different components without the need of global mode information. The mode-switch runtime mechanism has been verified by model checking in conjunction with mathematical proofs. We also provide a mode-switch timing analysis for the runtime mechanism to respect real-time requirements.   MSL is dedicated to the mode aspect of a system irrespective of component execution semantics, thus independent of the choice of component models. We have integrated MSL in the ProCom component model with the extension of support for reuse of multi-mode components and distributed mode-switch handling. Although the distributed mode-switch handling of MSL is more flexible and scalable than the conventional centralized approach, when components are deployed on a single hardware platform and global mode information is available, centralized mode-switch handling is more efficient in terms of runtime overhead and mode-switch time. Hence, MSL is supplemented with a mode transformation technique to enhance runtime mode-switch efficiency by converting the distributed mechanism to a centralized mechanism. MSL together with the mode transformation technique has been implemented in a prototype tool where one can build multi-mode systems by reusing multi-mode components. The applicability of MSL is demonstrated in two proof-of-concept case studies. / ARROWS - Design Techniques for Adaptive Embedded Systems

[Abstract]: The vast majority of present legacy information systems were implemented using the traditional paradigm. The traditional paradigm consists of modeling techniques used by system analysts such as System Flow Charts and Data Flow Diagrams (DFD) to capture, during the analysis phase, the activities within a system.However, with recent developments, particularly trends towards e-Commerce applications, platform independence, reusability of pre-built components, capacity for reconfiguration and higher reliability, many organizations are realizing they will need to re-engineer their systems into new component based systems that meet thesetrends given the limitations of legacy systems to adapt to these new technical requirements.There is a high degree of interest and concern in establishing whether or not a full migration to a more portable and scalable component-based architecture will be able to represent the legacy business requirements in the underlying requirements model of the re-engineered information systems.As a result, this study poses the question: Is the resulting component-based requirements model ontological equivalent to the legacy requirements model whenshifting paradigms in the re-engineering process?After a literature review, the research study is justified given the differences in requirements modeling between component-based and traditional paradigms, whichgive an indication that the resulting component model might not represent the same business requirements represented in the legacy system requirements model.The study evaluated the requirements models generated by the component-based and traditional approaches when shifting paradigms in the re-engineering process inorder to verify that the re-engineered component-based requirements model was capable of representing the same business requirements of the legacy system. Design science and an ontological evaluation using the Bunge-Wand-Weber(BWW) model were the central research methodologies for this study.A legacy system was selected as part of the case study and re-engineered by using the component-based paradigm with the help of UML diagrams. The requirements model of the legacy system was recovered using reverse engineering and compared to the component-based requirements model using normalized reference models generated with the help of BWW transformation maps. These maps revealed that there-engineered requirements models were capable of representing the same business requirements of the legacy system. A set of rules was suggested when reengineeringlegacy into component-based information systems to ensure the same representation of legacy system’s requirements in the re-engineered requirements model.Finally, this research included directions of future research that put emphasis on the development of automated software tools for systems re-engineering that couldimplement the rules suggested in this study and the ontological methodology approach used.

No description available.

Currently, the development of high-integrity embedded component-based software systems is not supported by well-integrated means allowing for quality evaluation and design support within a development process. Quality, especially dependability, is very important for such systems. The CHESS (Composition with Guarantees for High-integrity Embedded Software Components Assembly) project aims at providing a new systems development methodology to capture extra-functional concerns and extend Model Driven Engineering industrial practices and technology approaches to specifically address the architectural structure, the interactions and the behavior of system components while guaranteeing their correctness and the level of service at run time. The CHESS methodology is expected to be supported by a tool-set which consists of a set of plug-ins integrated within the Eclipse IDE. In the framework of the CHESS project, this thesis addresses the lack of well integrated means concerning quality evaluation and proposes an integrated framework to evaluate the dependability of high-integrity embedded systems. After a survey of various failure behavior analysis techniques, a specific technique, called Failure Propagation and Transformation Calculus (FPTC), is selected and a plug-in, called CHESS-FPTC, is developed within the CHESS tool-set. FPTC technique allows users to calculate the failure behavior of the system from the failure behavior of its building components. Therefore, to fully support FPTC, CHESS-FPTC plug-in allows users to model the failure behavior of the building components, perform the analysis automatically and get the analysis results back into their initial models. A case study about AAL2 Signaling Protocol is presented to illustrate and evaluate the CHESS-FPTC framework. / CHESS Project - http://chess-project.ning.com/

No description available.

¡@¡@There is a general agreement that information system (IS) is one of the effective solutions to help enterprises dealing with the challenge in today¡¦s dynamic environment. In response to the changing business environment, the need for a system with flexibility, high quality, and low cost has increased dramatically. Besides, end users more and more rely on IT (information technologies) or IS for their daily life or work. Therefore, how to attain high software throughput would be highly sought constantly. An idea of reusing previously developed modules, packages, components, software development methodologies, analysis data and test information has been attracting as a keystone to improve software productivity. This approach was called component-based development (CBD) or component-based software engineering (CBSE) and is becoming the main stream of software development. ¡@¡@Various CBD approaches, tools, and techniques were proposed in the literature, however the research on the integration of the above into an environment to enhance the system development is virtually lacking. Therefore, we proposed a framework of application generator, which integrates above approaches and concepts into a collaborative mechanism. Otherwise, we proposed a methodology based on our generator for end users to translate the business models or user requirements into the specification and construct application more efficient. Finally, we apply this methodology to a real-world case and generate the application by the generator in order to verify the feasibility.

Managed Extensibility Framework allows development of component-based .NET applications. However relations between components can be quite complex. Therefore the MEF Editor was implemented in context of author's bachelor thesis, which can visualise the relations according to source code analysis and provide their editing. Although possibilities of the analysis are determined by available user's extensions, in some cases the editor cannot be used. This master thesis provides a solution in form of a new version of the MEF Editor which increases the number of cases it can be used in. As part of this thesis, we implemented the editor with extensions allowing analysis of application projects written in C# language and compiled assemblies. It helps to detect composition errors in these applications and allows visual editing of source code where component architecture of these applications is implemented. Powered by TCPDF (www.tcpdf.org)

Nowadays, more and more embedded systems are equipped with e.g., various sensors that produce large amount of data. One of the challenges of traditional (CPU-based) embedded systems is to process this considerable amount of data such that it produces the appropriate performance level demanded by embedded applications. A solution comes from the usage of a specialized processing unit such as Graphics Processing Unit (GPU). A GPU can process large amount of data thanks to its parallel processing architecture, delivering an im- proved performance outcome compared to CPU. A characteristic of the GPU is that it cannot work alone; the CPU must trigger all its activities. Today, taking advantage of the latest technology breakthrough, we can benefit of the GPU technology in the context of embedded systems by using heterogeneous CPU-GPU embedded systems. Component-based development has demonstrated to be a promising methology in handling software complexity. Through component models, which describe the component specification and their interaction, the methodology has been successfully used in embedded system domain. The existing component models, designed to handle CPU-based embedded systems, face challenges in developing embedded systems with GPU capabilities. For example, current so- lutions realize the communication between components with GPU capabilities via the RAM system. This introduces an undesired overhead that negatively affects the system performance. This Licentiate presents methods and techniques that address the component- based development of embedded systems with GPU capabilities. More concretely, we provide means for component models to explicitly address the GPU-aware component-based development by using specific artifacts. For example, the overhead introduced by the traditional way of communicating via RAM is reduced by inserting automatically generated adapters that facilitate a direct component communication over the GPU memory. Another contribution of the thesis is a component allocation method over the system hardware. The proposed solution offers alternative options in opti- mizing the total system performance and balancing various system properties (e.g., memory usage, GPU load). For the validation part of our proposed solutions, we use an underwater robot demonstrator equipped with GPU hardware. / Ralf 3

Component-based development is an approach that revolves around the construction of systems form pre-built modular units (components). If legacy code can be reverse engineered to extract components, the extracted components can provide architectural re-usability across multiple systems of the same domain. Current component directed reverse engineering approaches are based on component models that belong to architecture description languages (ADLs). ADL-based components cannot be reused without configurational changes at code level and binding every required and provided service. Moreover, these component models neither support code-independent composition after extraction of components nor the re-deposition of a composed configuration of components for future reuse. This thesis presents a reverse engineering approach that extracts components and addresses the limitations of current approaches, together with a tool called RX-MAN. Unlike ADL-based approaches, the presented approach is based on an encapsulated component model called X-MAN. X-MAN components are encapsulated because computation cannot go outside of a component. X-MAN components cannot interact directly but only exogenously (composition is defined outside of a component). Our approach offers code-independent composition after extracting components and does not need binding of all the services like ADLs. The evaluation of our approach shows that it can facilitate the re-usability of legacy code by providing code-independent composition and re-deposition of composed configurations of components for further reuse and composition.