To see the other types of publications on this topic, follow the link: Component based architecture.
Dissertations / Theses on the topic 'Component based architecture'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Component based architecture.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Schmid, Stefan. "A component-based active router architecture." Thesis, Lancaster University, 2003. http://eprints.lancs.ac.uk/12227/.
Full text
2
Lewis, Joshua. "A COMMON COMPONENT-BASED SOFTWARE ARCHITECTURE FOR MILITARY AND COMMERCIAL PC-BASED VIRTUAL SIMULATION." Doctoral diss., University of Central Florida, 2006. http://digital.library.ucf.edu/cdm/ref/collection/ETD/id/2301.
Full textAbstract:
Commercially available military-themed virtual simulations have been developed and sold for entertainment since the beginning of the personal computing era. There exists an intense interest by various branches of the military to leverage the technological advances of the personal computing and video game industries to provide low cost military training. By nature of the content of the commercial military-themed virtual simulations, a large overlap has grown between the interests, resources, standards, and technology of the computer entertainment industry and military training branches. This research attempts to identify these commonalities with the purpose of systematically designing and evaluating a common component-based software architecture that could be used to implement a framework for developing content for both commercial and military virtual simulation software applications.<br>Ph.D.<br>Other<br>Engineering and Computer Science<br>Modeling and Simulation
3
Ong, Elwin 1979. "Fault protection in a component-based spacecraft architecture." Thesis, Massachusetts Institute of Technology, 2003. http://hdl.handle.net/1721.1/82804.
Full text
4
Ouimet, Martin 1975. "A diagnostics architecture for component-based system engineering." Thesis, Massachusetts Institute of Technology, 2004. http://hdl.handle.net/1721.1/17787.
Full textAbstract:
Thesis (S.M.)--Massachusetts Institute of Technology, Dept. of Aeronautics and Astronautics, 2004.<br>Includes bibliographical references (leaves 58-60).<br>This work presents an approach to diagnosis to meet the challenging demands of modern engineering systems. The proposed approach is an architecture that is both hierarchical and hybrid. The hierarchical dimension of the proposed architecture serves to mitigate the complexity challenges of contemporary engineering systems. The hybrid facet of the architecture tackles the increasing heterogeneity of modern engineering systems. The architecture is presented and realized using a bus representation where various modeling and diagnosis approaches can coexist. The proposed architecture is realized in a simulation environment, the Specification Toolkit and Requirements Methodology (SpecTRM). This research also provides important background information concerning approaches to diagnosis. Approaches to diagnosis are presented, analyzed, and summarized according to their strengths and domains of applicability. Important characteristics that must be considered when developing a diagnostics infrastructure are also presented alongside design guidelines and design implications. Finally, the research presents important topics for further research.<br>by Martin Ouimet.<br>S.M.
5
Zou, Li. "A New Architecture for Developing Component-based Distributed Applications." University of Cincinnati / OhioLINK, 2000. http://rave.ohiolink.edu/etdc/view?acc_num=ucin974951548.
Full text
6
Su, Jiancheng. "Component-based Intelligent Control Architecture for Reconfigurable Manufacturing Systems." Diss., Virginia Tech, 2007. http://hdl.handle.net/10919/29980.
Full textAbstract:
The present dynamic manufacturing environment has been characterized by a greater variety of products, shorter life-cycles of products and rapid introduction of new technologies, etc. Recently, a new manufacturing paradigm, i.e. Reconfigurable Manufacturing Systems (RMS), has emerged to address such challenging issues.
RMSs are able to adapt themselves to new business conditions timely and economically with a modular design of hardware/software system. Although a lot of research has been conducted in areas related to RMS, very few studies on system-level control for RMS have been reported in literature. However, the rigidity of current manufacturing systems is mainly from their monolithic design of control systems. Some new developments in Information Technology (IT) bring new opportunities to overcome the inflexibility that shadowed control systems for years.
Component-based software development gains its popularity in 1990â s. However, some well-known drawbacks, such as complexity and poor real-time features counteract its advantages in developing reconfigurable control system. New emerging Extensible Markup Language (XML) and Web Services, which are based on non-proprietary format, can eliminate the interoperability problems that traditional software technologies are incompetent to accomplish. Another new development in IT that affects the manufacturing sector is the advent of agent technology. The characteristics of agent-based systems include autonomous, cooperative, extendible nature that can be advantageous in different shop floor activities.
This dissertation presents an innovative control architecture, entitled Component-based Intelligent Control Architecture (CICA), designed for system-level control of RMS. Software components and open-standard integration technologies together are able to provide a reconfigurable software structure, whereas agent-based paradigm can add the reconfigurability into the control logic of CICA. Since an agent-based system cannot guarantee the best global performance, agents in the reference architecture are used to be exception handlers. Some widely neglected problems associated with agent-based system such as communication load and local interest conflicts are also studied. The experimental results reveal the advantage of new agent-based decision making system over the existing methodologies. The proposed control system provides the reconfigurability that lacks in current manufacturing control systems. The CICA control architecture is promising to bring the flexibility in manufacturing systems based on experimental tests performed.<br>Ph. D.
7
Adhikari, Rabindra. "The pursuit of sustainability : architecture and component based design." Virtual Press, 2007. http://liblink.bsu.edu/uhtbin/catkey/1370875.
Full textAbstract:
Architectural sustainability is ambiguous. The contemporary understanding of sustainability is often debated on the basis of environmental and humanitarian focus. This focus often brings ambiguity when the concept of sustainability is promoted as an end product and not as a perpetual process. For ecologically harmonious and sustainable human survival, sustainable methods and processes are believed to encourage reworking the course of human development.The Component-based design approach is a promising and appropriate method for achieving sustainability. The method involves systems thinking and illustrates characteristics like flexibility, resilience, adaptability and generative system. The focus of design should be in making relationships among these various components and processes, rather than emphasis on end product. This creative project illustrates these conceptual processes using computational logic to create a project for graphics and multimedia presentation.<br>Department of Architecture
8
Zhu, Liming Computer Science & Engineering Faculty of Engineering UNSW. "Software architecture evaluation for framework-based systems." Awarded by:University of New South Wales. Computer Science and Engineering, 2007. http://handle.unsw.edu.au/1959.4/28250.
Full textAbstract:
Complex modern software is often built using existing application frameworks and middleware frameworks. These frameworks provide useful common services, while simultaneously imposing architectural rules and constraints. Existing software architecture evaluation methods do not explicitly consider the implications of these frameworks for software architecture. This research extends scenario-based architecture evaluation methods by incorporating framework-related information into different evaluation activities. I propose four techniques which target four different activities within a scenario-based architecture evaluation method. 1) Scenario development: A new technique was designed aiming to extract general scenarios and tactics from framework-related architectural patterns. The technique is intended to complement the current scenario development process. The feasibility of the technique was validated through a case study. Significant improvements of scenario quality were observed in a controlled experiment conducted by another colleague. 2) Architecture representation: A new metrics-driven technique was created to reconstruct software architecture in a just-in-time fashion. This technique was validated in a case study. This approach has significantly improved the efficiency of architecture representation in a complex environment. 3) Attribute specific analysis (performance only): A model-driven approach to performance measurement was applied by decoupling framework-specific information from performance testing requirements. This technique was validated on two platforms (J2EE and Web Services) through a number of case studies. This technique leads to the benchmark producing more representative measures of the eventual application. It reduces the complexity behind the load testing suite and framework-specific performance data collecting utilities. 4) Trade-off and sensitivity analysis: A new technique was designed seeking to improve the Analytical Hierarchical Process (AHP) for trade-off and sensitivity analysis during a framework selection process. This approach was validated in a case study using data from a commercial project. The approach can identify 1) trade-offs implied by an architecture alternative, along with the magnitude of these trade-offs. 2) the most critical decisions in the overall decision process 3) the sensitivity of the final decision and its capability for handling quality attribute priority changes.
9
Myers, David S. "An Extensible Component-Based Architecture for Web-Based Simulation Using Standards-Based Web Browsers." Thesis, Virginia Tech, 2004. http://hdl.handle.net/10919/10123.
Full textAbstract:
Web-based simulation (WBS) systems offer tradeoffs between user interactivity and hardware requirements striking to seek a balance between the differing concerns. Server-based systems offer little interactivity or concurrent visualization capabilities, while client-based systems have increased hardware requirements asking the user to provide high-end workstations. Concurrent visualization of simulation output proves execution intensive, or unusable in some situations. Creating an execution efficient and user friendly WBS system greatly improves user experience while gaining all of the benefits inherent in a web-based system such as high accessibility and ease of maintenance. In order to provide a usable concurrent visualization WBS this thesis developed the Web-Based Queuing System Simulation System (WebQS3). WebQS3 splits the responsibilities of simulation execution and simulation visualization into a client-server environment; the client is responsible for the visualization display and server is responsible for simulation execution. The system differs from many previous WBS systems in that the client-side application is developed using web-standard technologies such as HTTP, XML, SVG, and ECMAScript instead relying on Java Applets and associated technologies. Using web-standards as the foundation of the client agent opens the visualization and model construction functionality to any user that accesses the application using a web browser while also making the application more scalable in terms of user load. Implementing the client with web-standards also included the development of an asynchronous client-server communication protocol as opposed to traditional synchronous communication protocols used by Java WBS systems. The asynchronous protocol demonstrates similar or better execution performance than similar synchronous communication protocols in most quality characteristics. By creating a WBS system using web-standards implemented in most modern web browsers any user may visit the WebQS3 site and have simulation tools available for use. Providing simulation services on the web makes eases the creation of simulation models my making the tools to readily available while facilitating information sharing and collaboration over the web. The WebQS3 system serves as a model to drive research in WBS systems away from proprietary Java technologies to web standards for front-end visualization technologies.<br>Master of Science
10
Admodisastro, Novia. "An integrated architecture analysis framework for component-based software development." Thesis, Lancaster University, 2011. http://eprints.lancs.ac.uk/61630/.
Full textAbstract:
The importance of architecture in reuse-driven development is widely recognized. Architecture provides a framework for establishing a match between available components and the system context. It is a key part of the system documentation; enforces the integrity of component composition and provides a basis for managing change. However, one of the most difficult problems in component-based system development (CBD) is ensuring that the software architecture provides an acceptable match with its intended application, business and evolutionary context. Unlike custom development where architectural design relies solely on a detailed requirements specification and where deficiencies in application context can be corrected by ‘tweaking’ the source code, in component-based system development the typical unit of development is often a black-box component whose source code is inaccessible to the developer. Getting the architecture right is therefore key to ensuring quality in a component-based system. Architecture analysis in CBD provides the developer with a means to expose interface mismatches, assess configurations with respect to specific structural and behavioural constraints and to verify the adequacy of compositions with respect to quality constraints. However, support for key component-based system design issues is still patchy in most architecture analysis approaches. My solution has been to develop, Component-based Software Architecture analysis FramEwork (CSAFE), a scenario-driven architecture analysis approach that combines and extends the strengths of current approaches using pluggable analysis. CSAFE is process- pluggable and recognises that negotiation (trade-off analysis) is central to black-box software development. However, while CSAFE is primarily intended to support black-box development, we recognise that there may be aspects of the system for which a black-box solution is not feasible. CSAFE supports custom development in such situations by treating abstract components as placeholders for custom development. CSAFE is supported by an extensible toolset.
11
McKean, David Keith. "Leveraging Model-Based Techniques for Component Level Architecture Analysis in Product-Based Systems." Thesis, The George Washington University, 2019. http://pqdtopen.proquest.com/#viewpdf?dispub=13812870.
Full textAbstract:
<p> System design at the component level seeks to construct a design trade space of alternate solutions comprising mapping(s) of system function(s) to physical hardware or software product components. The design space is analyzed to determine a near-optimal next-level allocated architecture solution that system function and quality requirements. Software product components are targeted to increasingly complex computer systems that provide heterogeneous combinations of processing resources. These processing technologies facilitate performance (speed) optimization via algorithm parallelization. However, speed optimization can conflict with electrical energy and thermal constraints. A multi-disciplinary architecture analysis method is presented that considers all attribute constraints required to synthesize a robust, optimum, extensible next-level solution. This paper presents an extensible, executable model-based architecture attribute framework that efficiently constructs a component-level design trade space. A proof-of-concept performance attribute model is introduced that targets single-CPU systems. The model produces static performance estimates that support optimization analysis and dynamic performance estimation values that support simulation analysis. This model-based approach replaces current architecture analysis of alternatives spreadsheet approaches. The capability to easily model computer resource alternatives that produces attribute estimates improves design space exploration productivity. Performance estimation improvements save time and money through reduced prototype requirements. Credible architecture attribute estimates facilitate more informed design tradeoff discussions with specialty engineers. This paper presents initial validation of a model-based architecture attribute analysis method and model framework using a single computation thread application on two laptop computers with different CPU configurations. Execution time estimates are calibrated for several data input sizes using the first laptop. Actual execution times on the second laptop are shown to be within 10 percent of execution time estimates for all data input sizes.</p><p>
12
Göbel, Steffen, Christoph Pohl, Ronald Aigner, Martin Pohlack, Simone Röttger, and Steffen Zschaler. "The COMQUAD Component Container Architecture and Contract Negotiation." Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2012. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-100181.
Full textAbstract:
Component-based applications require runtime support to be able to guarantee non-functional properties. This report proposes an architecture for a real-time-capable, component-based runtime environment, which allows to separate non-functional and functional concerns in component-based software development. The architecture is presented with particular focus on three key issues: the conceptual architecture, an approach including implementation issues for splitting the runtime environment into a real-time-capable and a real-time-incapable part, and details of contract negotiation. The latter includes selecting component implementations for instantiantion based on their non-functional properties.
13
Stoicescu, Miruna. "Architecting Resilient Computing Systems : a Component-Based Approach." Thesis, Toulouse, INPT, 2013. http://www.theses.fr/2013INPT0120/document.
Full textAbstract:
L'évolution des systèmes pendant leur vie opérationnelle est incontournable. Les systèmes sûrs de fonctionnement doivent évoluer pour s'adapter à des changements comme la confrontation à de nouveaux types de fautes ou la perte de ressources. L'ajout de cette dimension évolutive à la fiabilité conduit à la notion de résilience informatique. Parmi les différents aspects de la résilience, nous nous concentrons sur l'adaptativité. La sûreté de fonctionnement informatique est basée sur plusieurs moyens, dont la tolérance aux fautes à l'exécution, où l'on attache des mécanismes spécifiques (Fault Tolerance Mechanisms, FTMs) à l'application. A ce titre, l'adaptation des FTMs à l'exécution s'avère un défi pour développer des systèmes résilients. Dans la plupart des travaux de recherche existants, l'adaptation des FTMs à l'exécution est réalisée de manière préprogrammée ou se limite à faire varier quelques paramètres. Tous les FTMs envisageables doivent être connus dès le design du système et déployés et attachés à l'application dès le début. Pourtant, les changements ont des origines variées et, donc, vouloir équiper un système pour le pire scénario est impossible. Selon les observations pendant la vie opérationnelle, de nouveaux FTMs peuvent être développés hors-ligne, mais intégrés pendant l'exécution. On dénote cette capacité comme adaptation agile, par opposition à l'adaptation préprogrammée. Dans cette thèse, nous présentons une approche pour développer des systèmes sûrs de fonctionnement flexibles dont les FTMs peuvent s'adapter à l'exécution de manière agile par des modifications à grain fin pour minimiser l'impact sur l'architecture initiale. D'abord, nous proposons une classification d'un ensemble de FTMs existants basée sur des critères comme le modèle de faute, les caractéristiques de l'application et les ressources nécessaires. Ensuite, nous analysons ces FTMs et extrayons un schéma d'exécution générique identifiant leurs parties communes et leurs points de variabilité. Après, nous démontrons les bénéfices apportés par les outils et les concepts issus du domaine du génie logiciel, comme les intergiciels réflexifs à base de composants, pour développer une librairie de FTMs adaptatifs à grain fin. Nous évaluons l'agilité de l'approche et illustrons son utilité à travers deux exemples d'intégration : premièrement, dans un processus de développement dirigé par le design pour les systèmes ubiquitaires et, deuxièmement, dans un environnement pour le développement d'applications pour des réseaux de capteurs<br>Evolution during service life is mandatory, particularly for long-lived systems. Dependable systems, which continuously deliver trustworthy services, must evolve to accommodate changes e.g., new fault tolerance requirements or variations in available resources. The addition of this evolutionary dimension to dependability leads to the notion of resilient computing. Among the various aspects of resilience, we focus on adaptivity. Dependability relies on fault tolerant computing at runtime, applications being augmented with fault tolerance mechanisms (FTMs). As such, on-line adaptation of FTMs is a key challenge towards resilience. In related work, on-line adaption of FTMs is most often performed in a preprogrammed manner or consists in tuning some parameters. Besides, FTMs are replaced monolithically. All the envisaged FTMs must be known at design time and deployed from the beginning. However, dynamics occurs along multiple dimensions and developing a system for the worst-case scenario is impossible. According to runtime observations, new FTMs can be developed off-line but integrated on-line. We denote this ability as agile adaption, as opposed to the preprogrammed one. In this thesis, we present an approach for developing flexible fault-tolerant systems in which FTMs can be adapted at runtime in an agile manner through fine-grained modifications for minimizing impact on the initial architecture. We first propose a classification of a set of existing FTMs based on criteria such as fault model, application characteristics and necessary resources. Next, we analyze these FTMs and extract a generic execution scheme which pinpoints the common parts and the variable features between them. Then, we demonstrate the use of state-of-the-art tools and concepts from the field of software engineering, such as component-based software engineering and reflective component-based middleware, for developing a library of fine-grained adaptive FTMs. We evaluate the agility of the approach and illustrate its usability throughout two examples of integration of the library: first, in a design-driven development process for applications in pervasive computing and, second, in a toolkit for developing applications for WSNs
14
Göbel, Steffen, Christoph Pohl, Ronald Aigner, Martin Pohlack, Simone Röttger, and Steffen Zschaler. "The COMQUAD Component Container Architecture and Contract Negotiation." Technische Universität Dresden, 2004. https://tud.qucosa.de/id/qucosa%3A26291.
Full textAbstract:
Component-based applications require runtime support to be able to guarantee non-functional properties. This report proposes an architecture for a real-time-capable, component-based runtime environment, which allows to separate non-functional and functional concerns in component-based software development. The architecture is presented with particular focus on three key issues: the conceptual architecture, an approach including implementation issues for splitting the runtime environment into a real-time-capable and a real-time-incapable part, and details of contract negotiation. The latter includes selecting component implementations for instantiantion based on their non-functional properties.
15
Zhang, Huaxi Yulin. "Multi-dimensional architecture description language for forward and reverse evolution of component-based software." Thesis, Montpellier 2, 2010. http://www.theses.fr/2010MON20023/document.
Full textAbstract:
Les approches basées sur les composants permettent de développer des logiciels en réutilisant des composants existant dans des bibliothèques. La structure d'un tel logiciel produit par assemblage de composants est définie à l'aide d'un langage de description d'architectures (ADL). Les processus de développement sont encore peu adaptés à ce paradigme. Ainsi, les ADL existants ne fournissent pas de véritable support au développement et à l'évolution des architectures logicielles à composants. Cette thèse propose Dedal, un ADL permettant de définir une architecture logicielle à différents niveaux d'abstraction qui correspondent aux étapes du cycle de vie du logiciel : sa spécification, son implémentation et son déploiement. La définition de l'architecture est complétée par un modèle du logiciel à l'exécution. La cohérence entre les différentes définitions d'une architecture doit être assurée : sa définition à un niveau d'abstraction doit être conforme à sa définition à un niveau supérieur. Ce principe permet de contrôler l'évolution d'une architecture, en validant les modifications réalisées à un certain niveau d'abstraction ou en motivant la création d'une nouvelle version pour propager les modifications entre niveaux d'abstraction et rétablir la cohérence. Ces mécanismes préviennent les problèmes d'érosion ou de dérive qui surviennent lors des évolutions entre les différents niveaux de définition des architectures. Un environnement couvrant le cycle de vie complet d'un logiciel à base de composants a été prototypé. Il comporte un atelier, permettant de décrire des architectures avec Dedal, puis un environnement d'exécution, extension des outils Fractal, capable de contrôler l'évolution des architectures déployées. L'évolution à l'exécution est réalisée de façon graduelle, de manière à faire fonctionner et à instrumenter les nouvelles versions pendant une phase de transition, avant de valider définitivement une modification<br>Component-based approaches promote software development by reuse of existing components from a repository. The structure of such software is described as an assembly of software components using an architecture description language (ADL). Software development processes often do not comply with this paradigm yet. Consequently, existing ADLs do not fully support component-based software architecture development and evolution. This thesis proposes Dedal, an ADL to describe software architectures at several abstraction levels that correspond to the steps of software lifecycle: its specification, its implementation and its deployment. The architecture definition is completed with a runtime model of the software. Consistency between the various definitions of a given architecture must be maintained: its definition at some abstraction level must conform to its definition at a higher abstraction level. This consistency principle enables to control the evolution of architectures either validating changes performed at an abstraction level or motivating the creation of a new version, to propagate changes from an abstraction level to the other and restore their consistency. These mechanisms prevent from architecture erosion or drift which might occur between two different description levels after evolution. An environment that covers the whole lifecycle of component-based software has been prototyped. It includes a CASE tool that supports the Dedal-based description of architectures and a runtime environment that extends Fractal tools to control the evolution of the deployed software. Runtime evolution is performed gradually in order to have new versions run and instrumented during a transition phase before committing changes
16
Fiuczynski, Marc Eric. "Safe and efficient resource sharing in component-based systems /." Thesis, Connect to this title online; UW restricted, 2004. http://hdl.handle.net/1773/6992.
Full text
17
Aboud, Nour. "Service-Oriented Integration of Component and Organizational MultiAgent Models." Thesis, Pau, 2012. http://www.theses.fr/2012PAUU3019/document.
Full textAbstract:
Les travaux présentés dans cette thèse concernent des problématiques d'architecture logicielle multi-domaines pour le développement d’applications distribuées. Ces applications sont caractérisées aujourd’hui comme des systèmes ouverts, complexes, hétérogènes et à large échelle. Les approches traditionnelles, telles que l’approche orienté objet, n’offrent plus un paradigme de conception suffisant pour appréhender la complexité de tels systèmes. Ces nouvelles tendances ont conduit à l’émergence d’approches de plus haut niveau telles que les approches orientées services, composants ou agents. Chacune de ces approches offrent des intérêts et des caractéristiques propres dans le développement d’applications distribuées. Les services offrent une abstraction et une interopérabilité à large échelle. Abstraction dans le sens où un service permet de spécifier un élément fonctionnel sans préciser comment cet élément est implémenté. Les composants sont une approche robuste basée sur la composition et la réutilisation d’éléments clairement définis par leurs interfaces. Les agents sont eux des éléments présentant un comportement dynamique dirigé par un but et des interactions de haut niveau avec les autres agents formant l’application, vue comme une organisation de services collaboratifs. D’un point de vue conceptuel, le service peut donc être perçu comme le modèle « métier » de l’application, alors que les composants et les agents constituent un modèle d’implémentation. L’étude de ces différents domaines et des modèles associés, a montré que les approches composants et agents sont complémentaires, les points forts d’une approche représentant les faiblesses de l’autre. Face à ce constat, il nous est paru intéressant d’intégrer ces deux approches, au sein d’une même démarche de conception. Cela permet, d’une part, qu’une approche puisse bénéficier des intérêts de l’autre et d’autre part, d’utiliser conjointement des agents et des composants dans la conception d'une même application. La démarche que nous avons adoptée consiste à considérer les services comme pivot d’interaction afin de rendre possible l’interopérabilité des agents et des composants. Pour supporter cette démarche, nous avons défini un processus de conception basé sur l’Ingénierie Des Modèles qui contient quatre modèles conceptuels (Domain Specific language) dont l’intérêt est de mettre l’accent sur les concepts de services et d’interaction. Nous avons ainsi défini un modèle de services, un modèle de composants et un modèle d’agents. Enfin, un modèle mixte appelé CASOM, Component Agent Service Oriented Model, permet de spécifier une application via une combinaison des trois domaines précédents. Ensuite, des règles de correspondances ont été définies entre les quatre modèles pour pouvoir par exemple transformer une spécification agents en une spécification composants ou mixte. L'implémentation de ces transformations a été réalisée en langage ATL (ATLAS Transformation Language)<br>The presented work considers problems related to multi-domain software architecture for the development of distributed applications. These applications are large-scaled, heterogeneous, open and complex software systems. Traditional approaches such as object-oriented are no longer sufficient to represent such complex systems. These trends lead to the emergence of higher-level approaches such as service-oriented, components or agents. Each one of these approaches offers interests and characteristics in the development of distributed applications. Services provide an abstraction and interoperability in a large scale. Abstraction is in the sense that a service can specify a functional element without specifying how this element is implemented. The components are a robust approach based on composition and reusability through their clearly defined interfaces. Agents are elements which are characterized by dynamic goal directed behaviours and high-level interactions with other agents forming the application, seen as an organization for collaborative services. From a conceptual point of view, the service can be seen as the “business” model of an application, while components and agents are the implementation models. The study of these different domains, with their related models, showed that the components and agents approaches are complementary; the strengths of one approach overcome the weaknesses of the other. Therefore, we are interested in the integration of these two approaches in a single design approach. This allows an approach to benefit from the interests of the other, on one hand and the use of agents and components jointly in the design of an application on the other hand. To reach our objective, we consider services as pivot of interaction between agents and components. The result of our analysis leads us to develop a design process based on Model-Driven Engineering which contains four conceptual models (Domain Specific Languages) with the main interest of focusing on the concepts of services and interaction. We then defined a service, component and agent models. Finally, a hybrid model called CASOM, Component Agent Service Oriented Model, was proposed that allows application specification via a combination of the three domains. Then, mapping rules have been defined between the four models in order to transform agents specification into components specification or mixed. The implementation of these transformations was done in ATL language (ATLAS Transformation Language)
18
Tran, Tam M. Allen James O. "Interoperability and security support for heterogeneous Cots/Gots/legacy component-based architecture." Monterey, Calif. : Springfield, Va. : Naval Postgraduate School ; Available from National Technical Information Service, 2000. http://handle.dtic.mil/100.2/ADA383767.
Full textAbstract:
Thesis (M.S. in Software Engineering) Naval Postgraduate School, Sept. 2000.<br>Thesis advisor(s): LuQi; Shing, Mantak. "September 2000." Includes bibliographical references (p. 63-65). Also available in print.
19
Juric, Radmila. "Component based software architecture for interoperable databases and extensions to the results." Thesis, Brunel University, 2005. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.428342.
Full text
20
Tran, Tam M., and James O. Allen. "Interoperability and security support for heterogeneous Cots/Gots/legacy component-based architecture." Thesis, Monterey, California. Naval Postgraduate School, 2000. http://hdl.handle.net/10945/9419.
Full textAbstract:
There is a need for Commercial-off-the-shelf (COTS), Government-off- the-shelf (GOTS) and legacy components to interoperate in a secure distributed computing environment in order to facilitate the development of evolving applications. This thesis researches existing open standards solutions to the distributed component integration problem and proposes an application framework that supports application wrappers and a uniform security policy external to the components. This application framework adopts an Object Request Broker (ORB) standard based on Microsoft Distributed Component Object Model (DCOM). Application wrapper architectures are used to make components conform to the ORB standard. The application framework is shown to operate in a common network architecture. A portion of the Naval Integrated Tactical Environmental System I (NITES I) is used as a case study to demonstrate the utility of this distributed component integration methodology (DCIM).
21
Svensson, Tim. "Cloud based platform for real time Gait analysis : System component: Mobile architecture." Thesis, Högskolan i Halmstad, Akademin för informationsteknologi, 2017. http://urn.kb.se/resolve?urn=urn:nbn:se:hh:diva-34272.
Full textAbstract:
Today gait analysis are performed in laboratories with expensive equipment and people must visit the labs to perform several supervised tests. The goal of this project is to develop a platform enables gait analysis with the accelerometer sensor in a mobile phone. This would allow more people to do gait analysis, as smart phones are widely available and cheap equipment compared to lab equipments. In order to solve this task a mobile application and a cloud server was created. The mobile application can gather data from the internal accelerometer sensor and a medical grade sensor simultaneously and send the data to the cloud server. When two sensors are used the symmetry between the left foot and the right foot can be measured, although the system works with only one sensor aswell. On the cloud server the accelerometer data is analysed and gait analysis is done on the data and visualized on a web page. The mobile application can collect data for 4 hours at a sampling rate of 120Hz and two sensors are used. When sending data collected from two sensors to the cloud at a sampling rate of 120 Hz the amount of data is approximately 21.96 Mb/h. The goal of the project was to create a proof-of-concept platform to do gait analysis and that goal was fullled and a fully functional platform was developed.
22
Subramanian, Gayatri. "Automating Component-Based System Assembly." Thesis, Georgia Institute of Technology, 2006. http://hdl.handle.net/1853/11508.
Full textAbstract:
Owing to advancements in component re-use technology, component-based software development (CBSD) has come a long way in developing complex
commercial software systems while reducing software development time and cost. However, assembling distributed resource-constrained and
safety-critical systems using current assembly techniques is a challenge. Within complex systems when there are numerous ways to assemble the components unless the software architecture clearly defines how the components should be composed, determining the correct assembly that satisfies the system assembly constraints is
difficult. Component technologies like CORBA and .NET do a very good job of integrating components, but they do not automate component assembly; it is the system developer's responsibility to ensure thatthe components are assembled correctly.
In this thesis, we first define a component-based system assembly (CBSA) technique called "Constrained Component Assembly
Technique" (CCAT), which is useful when the system has complex assembly constraints and the system architecture specifies component composition as assembly constraints. The technique poses the question: Does there exist a way of assembling the components that satisfies all
the connection, performance, reliability, and safety constraints of the system, while optimizing the objective constraint?
To implement CCAT, we present a powerful framework called "CoBaSA". The CoBaSA framework includes an expressive language for declaratively describing component functional and extra-functional properties, component interfaces, system-level and component-level connection, performance, reliability, safety, and optimization constraints. To perform CBSA, we first write a program (in the CoBaSA language) describing the CBSA specifications and constraints, and then an interpreter translates the CBSA program into
a satisfiability and optimization problem. Solving the generated satisfiability and optimization problem is equivalent to answering the question posed by CCAT. If a satisfiable solution is found, we deduce that the system can be assembled without violating any constraints.
Since CCAT and CoBaSA provide a mechanism for assembling systems that have complex assembly constraints, they can be utilized in several
industries like the avionics industry. We demonstrate the merits of CoBaSA by assembling an actual avionic system that could be used on-board a Boeing aircraft. The empirical evaluation shows that our approach is promising and can scale to handle complex industrial problems.
23
Carlsson, Hampus, and Kärrman Marcus. "Cloud-based Mobile System for Free-Living Gait Analysis : System component : Server architecture." Thesis, Högskolan i Halmstad, Akademin för informationsteknologi, 2017. http://urn.kb.se/resolve?urn=urn:nbn:se:hh:diva-34293.
Full textAbstract:
Progress in the fields of wearable sensor technologies together with specialized analysis algorithms has enabled systems for gait analysis outside labs. An example of a wearable sensor is the accelerometer embedded in a typical smartphone. The goal was to propose a system design capable of hosting existing gait analysis algorithms in a cloud environment, and tailor the design as to deliver fast results with the ambition of reaching near real-time. The project identified a set of enabling technologies by examining existing systems for gait analysis; the technologies included cloud computing and WebSockets. The final system design is a hierarchical composition starting with a Linux VM running Node.js, which in turn connects to a database and hosts instances of the MatLab runtime. The results show the feasibility of mobile cloud based free-living gait analysis. The architectural design provides a solution to the critical problem of enabling existing algorithms to run in a cloud environment; and shows how the graphical output of the native algorithm could be accurately reproduced in a web browser. The system can process a chunk of 1300 data points under 3 seconds for a client streaming at 128 Hz, while simultaneously streaming the real time signal.
24
Bora, Prachi. "Runtime Algorithm Selection For Grid Environments: A Component Based Framework." Thesis, Virginia Tech, 2003. http://hdl.handle.net/10919/33823.
Full textAbstract:
Grid environments are inherently heterogeneous. If the computational power provided by collaborations on the Grid is to be harnessed in the true sense, there is a need for applications that can automatically adapt to changes in the execution environment. The application writer should not be burdened with the job of choosing the right algorithm and implementation every time the resources on which the application runs are changed.
A lot of research has been done in adapting applications to changing conditions. The existing systems do not address the issue of providing a unified interface to permit algorithm selection at runtime. The goal of this research is to design and develop a unified interface to applications in order to permit seamless access to different algorithms providing similar functionalities. Long running, computationally intensive scientific applications can produce huge amounts of performance data. Often, this data is discarded once the applicationâ s execution is complete. This data can be utilized in extracting information about algorithms and their performance. This information can be used to choose algorithms intelligently.
The research described in this thesis aims at designing and developing a component based unified interface for runtime algorithm selection in grid environments. This unified interface is necessary so that the application code does not change if a new algorithm is used to solve the problem. The overhead associated with making the algorithm choice transparent to the application is evaluated. We use a data mining approach to algorithm selection and evaluate its potential effectiveness for scientific applications.<br>Master of Science
25
Bora, Prachi Champalal. "Runtime Algorithm Selection For Grid Environments: A Component Based Framework." Thesis, Virginia Tech, 2003. http://hdl.handle.net/10919/33823.
Full textAbstract:
Grid environments are inherently heterogeneous. If the computational power provided by collaborations on the Grid is to be harnessed in the true sense, there is a need for applications that can automatically adapt to changes in the execution environment. The application writer should not be burdened with the job of choosing the right algorithm and implementation every time the resources on which the application runs are changed.
A lot of research has been done in adapting applications to changing conditions. The existing systems do not address the issue of providing a unified interface to permit algorithm selection at runtime. The goal of this research is to design and develop a unified interface to applications in order to permit seamless access to different algorithms providing similar functionalities. Long running, computationally intensive scientific applications can produce huge amounts of performance data. Often, this data is discarded once the applicationâ s execution is complete. This data can be utilized in extracting information about algorithms and their performance. This information can be used to choose algorithms intelligently.
The research described in this thesis aims at designing and developing a component based unified interface for runtime algorithm selection in grid environments. This unified interface is necessary so that the application code does not change if a new algorithm is used to solve the problem. The overhead associated with making the algorithm choice transparent to the application is evaluated. We use a data mining approach to algorithm selection and evaluate its potential effectiveness for scientific applications.<br>Master of Science
26
Tyan, Hung-ying. "Design, realization and evaluation of a component-based compositional software architecture for network simulation /." The Ohio State University, 2002. http://rave.ohiolink.edu/etdc/view?acc_num=osu1486402544591791.
Full text
27
McLeod, Charles S. "Development of a toolkit for component-based automation systems." Thesis, Loughborough University, 2013. https://dspace.lboro.ac.uk/2134/12657.
Full textAbstract:
From the earliest days of mass production in the automotive industry there has been a progressive move towards the use of flexible manufacturing systems that cater for product variants that meet market demands. In recent years this market has become more demanding with pressures from legislation, globalisation and increased customer expectations. This has lead to the current trends of mass customisation in production. In order to support this manufacturing systems are not only becoming more flexible† to cope with the increased product variants, but also more agile‡ such that they may respond more rapidly to market changes. Modularisation§ is widely used to increase the agility of automation systems, such that they may be more readily reconfigured¶. Also with globalisation into India and Asia semi-automatic machines (machines that interact with human operators) are more frequently used to reduce capital outlay and increase flexibility. There is an increasing need for tools and methodologies that support this in order to improve design robustness, reduce design time and gain a competitive edge in the market. The research presented in this thesis is built upon the work from COMPAG/COMPANION (COMponent- based Paradigm for AGile automation, and COmmon Model for PArtNers in automatION), and as part of the BDA (Business Driven Automation), SOCRADES (Service Oriented Cross-layer infrastructure for Distributed smart Embedded deviceS), and IMC-AESOP (ArchitecturE for Service- Oriented Process – monitoring and control) projects conducted at Loughborough University UK. This research details the design and implementation of a toolkit for building and simulating automation systems comprising components with behaviour described using Finite State Machines (FSM). The research focus is the development of the engineering toolkit that can support the automation system lifecycle from initial design through commissioning to maintenance and reconfiguration as well as the integration of a virtual human. This is achieved using a novel data structure that supports component definitions for control, simulation, maintenance and the novel integration of a virtual human into the automation system operation.
28
Persson, Magnus. "A Formalized Approach to Multi-View Components for Embedded Systems : Applied to Tool Integration, Run-Time Adaptivity and Architecture Exploration." Doctoral thesis, KTH, Inbyggda styrsystem, 2013. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-122487.
Full textAbstract:
Development of embedded systems poses an increasing challenge fordevelopers largely due to increasing complexity. Several factors contribute tothe complexity challenge: • the number of extra-functional properties applying to embedded systems,such as resource usage, timing effects, safety. • the functionality of embedded systems, to a larger extent than for othersoftware, involves engineers from multiple different disciplines, such asmechanical, control, software, safety, systems and electrical engineers.Themulti-disciplinarity causes the development environments to consistof separate data, models and tools. Several engineering paradigms to handle this complexity increase havebeen suggested, including methodologies focused on architecture, models andcomponents. In systems engineering, a long-standing approach has been todescribe the system in several views, each according to a certain viewpoint.By doing so, a divide-and-conquer strategy is applied to system concerns.Unfortunately, it is hard to always find completely independent concerns:there is always some semantic overlap between the different views. Modelbaseddesign (MBD) deals with building sound abstractions that can representa system under design and be used for analysis. Component-based design(CBD) focuses on how to build reusable component models with well-definedcomposition models. In this thesis, a concept of formalized multi-viewed component models (MVCM) is proposed, which integrates the three above mentioned paradigms.Principles and guidelines for MV CMs are developed. One of the main challengesfor the proposition is to provide MV CMs that produce composabilityboth along component boundaries and viewpoint boundaries. To accomplishthis, the relations between viewpoints need to be explicitly taken into account.Further, the semantic relations between these viewpoints need to be explicitlymodeled in order to efficiently ensure that the views are kept consistent. Asa main contribution, this thesis presents the formalization of the conceptsneeded to build such component models. A proper formalization of multiviewedconcerns provides several opportunities. Given suitable tool support, itwill be feasible to automate architecture analysis and architecture exploration. The thesis includes a number of case studies that provide insight andfeedback to the problem formulation and validating the results. The casestudies include a resource-aware reconfigurable middleware, a design of anarchitecture exploration methodology, and a windshield wiper system.<br><p>QC 20130527</p>
29
Mokni, Abderrahman. "A formal approach to automate the evolution management in component-based software development processes." Thesis, Montpellier, 2015. http://www.theses.fr/2015MONTS131/document.
Full textAbstract:
Gérer l'évolution des logiciels est une tâche complexe mais nécessaire. Tout au long de son cycle de vie, un logiciel doit subir des changements, pour corriger des erreurs, améliorer ses performances et sa qualité, étendre ses fonctionnalités ou s’adapter à son environnement. A défaut d’évoluer, un logiciel se dégrade, devient obsolète ou inadapté et est remplacé. Cependant, sans évaluation de leurs impacts et contrôle de leur réalisation, les changements peuvent être sources d’incohérences et de dysfonctionnements, donc générateurs de dégradations du logiciel. Cette thèse propose une approche améliorant la gestion de l'évolution des logiciels dans les processus de développement orientés composants. Adoptant une démarche d’ingénierie dirigée par les modèles (IDM), cette approche s’appuie sur Dedal, un langage de description d’architecture (ADL) séparant explicitement trois niveaux d’abstraction dans la définition des architectures logicielles. Ces trois niveaux (spécification, configuration et assemblage) correspondent aux trois étapes principales du développement d’une architecture (conception, implémentation, déploiement) et gardent la trace des décisions architecturales prises au fil du développement. Ces informations sont un support efficace à la gestion de l’évolution : elles permettent de déterminer le niveau d’un changement, d’analyser son impact et de planifier sa réalisation afin d’éviter la survenue d’incohérences dans la définition de l’architecture (érosion, dérive, etc.). Une gestion rigoureuse de l’évolution nécessite la formalisation, d’une part, des relations intra-niveau liant les composants au sein des modèles correspondant aux différents niveaux de définition d’une architecture et, d’autre part, des relations inter-niveaux liant les modèles décrivant une même architecture aux différents niveaux d’abstraction. Ces relations permettent la définition des propriétés de consistance et de cohérence servant à vérifier la correction d’une architecture. Le processus d’évolution est ainsi décomposé en trois phases : initier le changement de la définition de l’architecture à un niveau d’abstraction donné ; vérifier et rétablir la consistance de cette définition en induisant des changements complémentaires ; vérifier et rétablir la cohérence globale de la définition de l’architecture en propageant éventuellement les changements aux autres niveaux d’abstraction.Ces relations et propriétés sont décrites en B, un langage de modélisation formel basé sur la théorie des ensembles et la logique du premier ordre. Elles s’appliquent à des architectures définies avec un adl formel écrit en B dont le méta-modèle, aligné avec celui de Dedal, permet d’outiller la transformation de modèles entre les deux langages. Cette intégration permet de proposer un environnement de développement conjuguant les avantages des approches IDM et formelle : la conception d’architectures avec l’outillage de Dedal (modeleur graphique); la vérification des architectures et la gestion de l’évolution avec l’outillage de B (animateur, model-checker, solver). Nous proposons en particulier d’utiliser un solver B pour calculer automatiquement des plans d’évolution conformes à notre proposition et avons ainsi défini l’ensemble des règles d’évolution décrivant les opérations de modification applicables à la définition d’une architecture. Le solver recherche alors automatiquement une séquence de modifications permettant la réalisation d’un changement cible tout en préservant les propriétés de consistance et de cohérence de l’architecture. Nous avons validé la faisabilité de cette gestion de l’évolution par une implémentation mêlant optimisation et génie logiciel (search-based software engineering), intégrant notre propre solver pourvu d’heuristiques spécifiques qui améliorent significativement les temps de calcul, pour expérimenter trois scénarios d’évolution permettant de tester la réalisation d’un changement à chacun des trois niveaux d’abstraction<br>Managing software evolution is a complex task. Indeed, throughout their whole lifecycle, software systems are subject to changes to extend their functionalities, correct bugs, improve performance and quality, or adapt to their environment. If not evolved, software systems degrade, become obsolete or inadequate and are replaced. While unavoidable, software changes may engender several inconsistencies and system dysfunction if not analyzed and handled carefully hence leading to software degradation and phase-out.This thesis proposes an approach to improve the evolution management activity in component-based software development processes. The solution adopts a Model-Driven Engineering (MDE) approach. It is based on Dedal, an Architecture Description Language (ADL) that explicitly separates software architecture descriptions into three abstraction levels: specification, configuration and assembly. These abstraction levels respectively correspond to the three major steps of component-based development (design, implementation and deployment) and trace architectural decisions all along development. Dedal hence efficiently supports evolution management: It enables to determine the level of change, analyze its impact and plan its execution in order to prevent architecture inconsistencies (erosion, drift, etc.). Rigorous evolution management requires the formalization, on the one hand, of intra-level relations linking components within models corresponding to different architecture abstraction levels and on the other hand, of the formalization of inter-level relations linking models describing the same architecture at different abstraction levels. These relations enable the definition of the consistency and coherence properties that prove necessary for architecture correctness analysis. The evolution process therefore consists of three steps: First, change is initiated on an architecture description at a given abstraction level; then, the consistency of the impacted description is checked out and restored by triggering additional changes; finally, the global coherence of the architecture definitions is verified and restored by propagating changes to other abstraction levels.Relations and properties are expressed in B, a set-theoretic and first-order logic language. They are applied on B formal ADL, the meta-model of which is mapped to Dedal's and helps automatic model transformations. This integration enables to implement a development environment that combines the benefits of both MDE and formal approaches: Software architecture design using Dedal tools (graphical modeler) and architecture analysis and evolution management using B tools (animator, model-checker, solver).In particular, we propose to use a B solver to automatically calculate evolution plans according to our approach. The solver explores a set of defined evolution rules that describe the change operations that can apply on architecture definitions. It automatically searches for a sequence of operations that both changes the architecture as requested and preserves architecture consistency and coherence properties. The feasibility of the evolution management approach is demonstrated through the experimentation of three evolution scenarios, each addressing a change at different abstraction level. The experimentation relies on an implementation of a search-based software engineering approach mixing software engineering and optimization and integrates our own solver with specific heuristics that significantly improve calculation time
30
Sartipi, Kamran. "Software Architecture Recovery based on Pattern Matching." Thesis, University of Waterloo, 2003. http://hdl.handle.net/10012/1122.
Full textAbstract:
Pattern matching approaches in reverse engineering aim to incorporate domain knowledge and system documentation in the software architecture extraction process, hence provide a user/tool collaborative environment for architectural design recovery. This thesis presents a model and an environment for recovering the high level design of legacy software systems based on user defined architectural patterns and graph matching techniques.
In the proposed model, a high-level view of a software system in terms of the system components and their interactions is represented as a query, using a description language. A query is mapped onto a pattern-graph, where a module and its interactions with other modules are represented as a group of graph-nodes and a group of graph-edges, respectively. Interaction constraints can be modeled by the description language as a part of the query. Such a pattern-graph is applied against an entity-relation graph that represents the information extracted from the source code of the software system. An approximate graph matching process performs a series of graph edit operations (i. e. , node/edge insertion/deletion) on the pattern-graph and uses a ranking mechanism based on data mining association to obtain a sub-optimal solution. The obtained solution corresponds to an extracted architecture that complies with the given query.
An interactive prototype toolkit implemented as part of this thesis provides an environment for architecture recovery in two levels. First the system is decomposed into a number of subsystems of files. Second each subsystem can be decomposed into a number of modules of functions, datatypes, and variables.
31
Rahman, Asim. "Metrics for the Structural Assessment of Product Line Architecture." Thesis, Blekinge Tekniska Högskola, Avdelningen för programvarusystem, 2004. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-3427.
Full textAbstract:
The notion of maximizing software reuse among the family of products has gained considerable attention in the last decade. Lots of research has been done on designing and managing the commonalities and variabilities between the products. However, very few metrics have been developed to assist architects in designing product line architectures. The structure of the product line holds immense importance towards increasing the life span of the product line. Since many of the product line architecture design methodologies follow a component based approach, it seems logical to attempt to adapt the component based metrics to the product line domain. In this thesis, we attempt to derive metrics that quantify the structural quality of product line architecture.<br>+92-42-5727639
32
JUNIOR, CELSO GOMES BARRETO. "ADDING SYSTEM INTRASTRUCTURE FRAMEWORKS IN AN COMPONENT BASED ARCHITECTURE: A CASE STUDY WITHIN THE AULANET ENVIRONMENT." PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO, 2006. http://www.maxwell.vrac.puc-rio.br/Busca_etds.php?strSecao=resultado&nrSeq=8623@1.
Full textAbstract:
COORDENAÇÃO DE APERFEIÇOAMENTO DO PESSOAL DE ENSINO SUPERIOR<br>FUNDAÇÃO PADRE LEONEL FRANCA<br>Groupware é difícil de construir e de manter, pois envolve
aspectos
multidisciplinares. Além das dificuldades associadas ao
desenvolvimento de
aplicações colaborativas, usualmente o desenvolvedor de
groupware deve se
preocupar com outros aspectos de infra-estrutura. Nesta
dissertação é proposta
uma arquitetura multicamadas baseada em componentes para
groupware,
utilizando frameworks de infra-estrutura. Na camada de
negócio são utilizados os
frameworks Hibernate, responsável pela persistência dos
dados da aplicação, e o
framework Spring, que dentre outras coisas é responsável
pelo controle de
transações e pela exposição de serviços remotamente. Na
camada de apresentação
o framework JaveServer Faces provê meios para criar e
reusar componentes de
interface. Nesta dissertação também é apresentada uma forma
de comparar
frameworks de infra-estrutura, levando em consideração
tanto aspectos técnicos,
que definem se o framework atende aos requisitos da
aplicação, quanto nãotécnicos,
relacionados a aspectos como documentação disponível e
aceitação no
mercado. A arquitetura definida nesta dissertação é
aplicada no AulaNet,
groupware voltado para a aprendizagem desenvolvido no
Laboratório de
Engenharia de Software da PUC-Rio.<br>Groupware is difficult to develop and maintain because it
involves
multidisciplinary aspects in its construction. Besides the
difficulties related to the
development of collaborative applications, usually the
developer must handle with
other infrastructure aspects. In this dissertation, it is
proposed a multilayer
component based architecture with system infrastructure
frameworks to deal with
them. In the business layer, the Hibernate framework is
responsible for the
persistence of application data, and the Spring framework
is responsible for,
amongst others, transactions control and remote exposition
of services. In the
presentation layer the JaveServer Faces framework provides
ways to create and to
reuse user-interface components. This dissertation also
presents a way to compare
system infrastructure frameworks, considering both
technical aspects, related to
the application requirements fulfillment, and non-
technical, related to aspects such
as documentation availability and market acceptance. The
architecture defined in
this dissertation is applied to the AulaNet, which is a
groupware for learning
developed in the Software Engineering Laboratory of PUC-Rio.
33
Barot, Vishal A. "Operator interfaces for the lifecycle support of component based automation systems." Thesis, Loughborough University, 2012. https://dspace.lboro.ac.uk/2134/9830.
Full textAbstract:
Current manufacturing automation systems (specifically the powertrain sector) have been facing challenges with constant pressures of globalisation, environmental concerns and ICT (Information and Communication Technology) innovations. These challenges instigate new demands for shorter product lifecycles and require customised products to be manufactured as efficiently as possible. Manufacturing systems must therefore be agile to remain competitive by supporting frequent reconfigurations involving distributed engineering activities.
34
Dai, Wenbin. "On migration of scan cycle based PLC programs to distributed component-based event driven software architecture with semantic correctness assurance." Thesis, University of Auckland, 2012. http://hdl.handle.net/2292/19374.
Full textAbstract:
In current automation world, majority of systems are designed using programmable logic controllers (PLC) under the IEC 61131-3 standard. The IEC 61131-3 standard PLCs are struggling with increasing demand for reconfigurability and flexibility in distributed control systems. The IEC 61499 standard is considered as the key of enabling distributed and intelligent control into industrial automation. However, the use of the IEC 61499 standard in the automation industry is still minimal. Although advantages of replacing legacy systems with function block controlled systems are substantial, the learning curve is quite steep and the cost of required research and development is high. Introducing the IEC 61499 standard into the IEC 61131-3 based systems provides flexibility and reconfigurability as well as a better graphical view of system designs. Therefore it is important to provide an easy migration path for existing PLC programs into IEC 61499 compliant platforms as the first step towards widespread adoption of the new standard. This research presented in this thesis proposes a new methodology of migration from IEC 61131-3 PLCs to IEC 61499 function blocks. The aim of this migration process is to recreate IEC 61131-3 applications in IEC 61499 implementations with equivalent execution behaviour. The formal model of the IEC 61131-3 standard and formal cyclical execution model is included. This method also creates a foundation for correct-by-design development tools and automatic migration between the IEC 61131-3 and the IEC 61499 standards. Formal migration rules based on ontology mappings, restoring execution model including tasks and programs scheduling and variables mapping with different access levels are also provided. A transformation engine for import PLC code in XML format, mapping from PLC ontology model to Function Block model and code generation is implemented based on an ontological knowledge base and semantic query-enhanced web rule language. This research also proposes a new approach for semantic analysis using multiple-layered ontological knowledge base and rule-based configurable engine. The semantic rules of the IEC 61499 standard are proposed.
35
Chigani, Amine. "Guiding Network-Centrtic Architectural Design: a Style-Based Approach." Thesis, Virginia Tech, 2007. http://hdl.handle.net/10919/36451.
Full textAbstract:
With the advance of reliable network technology, software development has progressed from traditional, platform-centric software construction to network-centric software evolution. An evidence of this change is largely reflected in the technologies that are supporting the emerging theory of Network-Centric Operations (NCO). Amongst these technologies is software architecture as a software engineering sub-discipline. Although the concepts of network centricity are widely recognized within the software and system engineering communities, no unified characterization of network-centric software systems is unanimously adopted. The state-of-the-practice is characterized by differing interpretations about how we should design and implement this class of systems. In this research, our focus is twofold: 1) Providing a characterization framework to reason about network-centric software systems and 2) introducing one solution approach to designing this class of system based on a new architectural style, the network-centric architectural style. In so doing, we set the stage for the software architecture community to analyze the â fitness of useâ of current architectural styles and architecture design practices within this new network-centric paradigm. In addition, we set the stage for our continued research that will address further software engineering challenges pertinent to network-centric software systems, which include capability-based requirements engineering and quality attributes-based design.<br>Master of Science
36
Carrillo, Rozo Oscar. "Formal and incremental verification of SysML for the design of component-based system." Thesis, Besançon, 2015. http://www.theses.fr/2015BESA2017/document.
Full textAbstract:
Vérification Formelle et Incrémentale de Spécifications SysML pour la Conception de Systèmes à Base de ComposantsLe travail présenté dans cette thèse est une contribution à la spécification et la vérification des Systèmes à Base de Composants (SBC) modélisé avec le langage SysML. Les SBC sont largement utilisés dans le domaine industrielet ils sont construits en assemblant différents composants réutilisables, permettant ainsi le développement de systèmes complexes en réduisant leur coût de développement. Malgré le succès de l'utilisation des SBC, leur conception est une étape de plus en plus complexe qui nécessite la mise en {\oe}uvre d'approches plus rigoureuses.Pour faciliter la communication entre les différentes parties impliquées dans le développement d'un SBC, un des langages largement utilisé est SysML, qui permet de modéliser, en plus de la structure et le comportement du système, aussi ses exigences. Il offre un standard de modélisation, spécification et documentation de systèmes, dans lequel il est possible de développer un système, partant d'un niveau abstrait, vers des niveaux plus détaillés pouvant aboutir à une implémentation. %Généralement ces systèmes sont faits plus grands parce qu'ils sont développés avec des cadres logiciels.Dans ce contexte nous avons traité principalement deux problématiques.La première est liée au développement par raffinement d'un SBC modélisé uniquement par ses interfaces SysML. Notre contribution permet au concepteur des SBC de garantir formellement qu'une composition d'un ensemble de composants élémentaires et réutilisables raffine une spécification abstraite d'un SBC. Dans cette contribution, nous exploitons les outils: Ptolemy pour la vérification de la compatibilité des composants assemblés, et l'outil MIO Workbench pour la vérification du raffinementLa deuxième problématique traitée concerne la difficulté de déterminer quoi construire et comment le construire, en considérant seulement les exigences du système et des composants réutilisables, donc la question qui en découle est la suivante: comment spécifier une architecture SBC qui satisfait toutes les exigences du système? Nous proposons une approche de vérification formelle incrémentale basée sur des modèles SysML et des automates d'interface pour guider, par les exigences, le concepteur SBC afin de définir une architecture de système cohérente, qui satisfait toutes les exigences SysML proposées. Dans cette approche nous exploitons le model-checker SPIN et la LTL pour spécifier et vérifier les exigences.Mots clés: {Modélisation, Spécifications SysML, Architecture SBC, Raffinement, Compatibilité, Exigences, Propriétés LTL, Promela/SPIN, Ptolemy, MIO Workbench}<br>Formal and Incremental Verification of SysML Specifications for the Design of Component-Based SystemsThe work presented in this thesis is a contribution to the specification and verification of Component-Based Systems (CBS) modeled in SysML. CBS are widely used on the industrial field, and they are built by assembling various reusable components, allowing developing complex systems at lower cost.Despite the success of the use of CBS, their design is an increasingly complex step that requires the implementation of more rigorous approaches.To ease the communication between the various stakeholders in a CBS development project, one of the widely used modeling languages is SysML, which besides allowing modeling of structure and behavior, it has capabilities to model requirements. It offers a standard for modeling, specifying and documenting systems, wherein it is possible to develop a system, starting from an abstract level, to more detailed levels that may lead to an implementation.In this context, we have dealt mainly two issues. The first one concerns the development by refinement of a CBS, which is described only by its SysML interfaces and behavior protocols. Our contribution allows the designer of CBS to formally ensure that a composition of a set of elementary and reusable components refines an abstract specification of a CBS. In this contribution, we use the tools: Ptolemy for the verification of compatibility of the assembled components and MIO Workbench for refinement verification.The second one concerns the difficulty to decide what to build and how to build it, considering only system requirements and reusable components. Therefore, the question that arises is: how to specify a CBS architecture, which satisfies all system requirements? We propose a formal and incremental verification approach based on SysML models and interface automata to guide, by the requirements, the CBS designer to define a coherent system architecture that satisfies all proposed SysML requirements. In this approach we use the SPIN model-checker and LTL properties to specify and verify requirements.Keywords: {Modeling, SysML specifications, CBS architecture, Refinement, Compatibility, Requirements, LTL properties, Promela/SPIN, Ptolemy, MIO Workbench}
37
Krosche, Martin [Verfasser], and Hermann [Akademischer Betreuer] Matthies. "A Generic Component-Based Software Architecture for the Simulation of Probabilistic Models / Martin Krosche ; Betreuer: Hermann Matthies." Braunschweig : Technische Universität Braunschweig, 2012. http://d-nb.info/1175822442/34.
Full text
38
Valskis, Justas. "Deklaratyviai apibrėžiamų komponentų architektūra: projektavimas ir realizacija Java sistemoje." Master's thesis, Lithuanian Academic Libraries Network (LABT), 2014. http://vddb.library.lt/obj/LT-eLABa-0001:E.02~2012~D_20140704_172322-85008.
Full textAbstract:
Šio darbo tikslas yra sukurti metodą, kuris teiktų galimybę kuo didesnę vartotojo sąsajos dalį apibrėžti deklaratyviai (komponentų kūrimas, įvykių klausytojų registravimas, komponentų tarpusavio sąryšių apibrėžimas ir vizualus komponentų išdėstymas languose). Darbe išanalizuotos įvairios komponentinės architektūros bei išraiškingą vartotojo sąsajos apibrėžimą įgalinantys sprendimai. Apibrėžta ir įgyvendinta architektūra leidžianti kurti deklaratyviai apibrėžiamus vartotojo sąsajos komponentus, kurie deklaruoja savo elgesį ir gali bendrauti tarpusavyje pranešimų pagalba. Rezultate buvo sukurta sistema, kuri leidžia kurti taikomąsias programas su Java Swing vartotojo sąsaja, naudojantis beveik vien tik deklaratyviais taikomosios programos dalių apibrėžimais. Sukurtos sistemos konfigūracijos galimybės leidžia sumažinti komponentų manipuliacijai skirto Java kodo poreikį.<br>A part of a user interface can be created using declarative means. The main goal of this paper is to maximize that portion. To do that, said means would be used to create components, register event listeners, describe relationships between components and layout them in windows. Various component-based architectures and existing solutions for declarative user interface definition were analyzed. As a result, an architecture was defined which allows user interface components to be created using a declarative approach. These components define their behavior and use messages to communicate with each other. The outcome was a system, which can create Java Swing applications using mostly declarative definitions of various parts of said applications. This system provides various configuration options that reduce the need of writing Java code for component manipulation.
39
Rais, Aziz. "Interface-Based Software Development." Doctoral thesis, Vysoká škola ekonomická v Praze, 2017. http://www.nusl.cz/ntk/nusl-264730.
Full textAbstract:
Even though there are many software development and project management methodologies available, research and practice both show that IT software development projects still fail, and that the quality of software products does not always meet customers' expectations. There might be multiple causes for such failures, but some of these reasons can be seen to influence or create others. Therefore, the larger the project is, the higher its risk of failure, especially if the teams involved work remotely (distributed and outsourced). This increase in project complexity is considered the motivation for this paper. Similarly, there are other factors that can result in a project's failure and customers' dissatisfaction regarding software quality. All such factors identified by research conducted by organizations specializing in this area are analyzed in order to identify a common root of IT project failures. Once the root causes of these failures have been identified and analyzed, the goal of the Interface based software development methodology is to solve them. The solution offered by an Interface based software development methodology is to improve understanding of software requirements and to describe these requirements with interfaces in an object-oriented way. Interface based software development will support and drive development towards service-oriented architecture (SOA) and component-based development (CBD). The goal of interface based software development is to increase software testability and maintainability and to make it more easily feasible to execute various software development processes in parallel.
40
Vardhan, K. Ananda. "Language Support For Testing CORBA Based Applications." Thesis, Indian Institute of Science, 2001. http://hdl.handle.net/2005/173.
Full textAbstract:
Component Based Development has emerged as economical, reusable, scalable way of developing enterprise as well as embedded software applications. Testing distributed component based systems is difficult when third party components are being used in the development. Many testing methodologies that have been proposed for testing object oriented programs in the literature are being imported into component domain directly or by tuning them. But testing components involves much manual work due to the lack of information of the component. Middleware architectures like, DCOM(Distributed COM), Jini and CORBA(Common Object Request Broker Architecture) are being used in developing the distributed component applications in different vertical domains.
In this thesis, a language- Distributed Object Testing Language(DOTL) for specifying the testing process and generation of distributed testing environment for CORBA based applications has been proposed. The language captures required semantics for specifying dummy servers, clients, controlling the testing process, generation of test cases, activating and deactivating objects. Many existing testing techniques can be specified using the semantics provided by the language. Faults occurring in distributed object systems, in addition to the functional errors, can be identifiable using the tool. The language provides abstract types object, argument to specify variables in the testing environment, and operations dealing with these variables to conducts necessary tests.
The DOTL has been implemented on MICO(Mico Is CORBA) orb on Linux OS, with mapping of DOTL to CORBA C++.
41
Ait, Lahcen Ayoub. "Developing component-based applications with a data-centric approach and within a service-oriented P2P architecture : specification, analysis and middleware." Nice, 2012. http://www.theses.fr/2012NICE4084.
Full textAbstract:
Le développement d’applications avec une architecture Pair-à-Pair (P2P) est devenu de plus en plus important en ingénierie du logiciel. Aujourd’hui, un grand nombre d’organisations de tailles et secteurs différents compte d’une manière croissante sur la collaboration entre multiples acteurs (individus, groupes, communautés, etc. ) pour accomplir des tâches essentielles. Ces applications P2P ont généralement un comportement récursif que plusieurs approches de modélisation ne peuvent pas décrire et analyser (exemple : les approches basées sur les automates à états finis). Un autre challenge qui concerne le développement d’applications P2P est le couplage fort entre la spécification d’une part, et les technologies et protocoles sous-jacents d’autre part. Cela force les développeurs à faire des efforts considérables pour trouver puis comprendre des informations sur les détails de ces couches casses du P2P. De plus, ce couplage fort oblige les applications à s’exécuter dans des environnements figés. Par conséquent, choisir par exemple un autre protocole pour répondre à un nouveau besoin à l’exécution devient une tâche très difficile. Outre ces points, les applications P2P sont souvent spécifiées avec une faible capacité à déléguer des traitements entre les pairs, et se focalisent surtout sur le partage et le stockage de données. Ainsi, elles ne profitent pas pleinement de la puissance de calcul et de traitement offerte par le réseau P3P sous-jacent. Dans cette thèse, nous présentons une approche qui combine les principes du développement orienté composants et services avec des techniques issues des Grammaires Attribuées et d’Analyses de flot de données (techniques utilisées surtout dans la construction de compilateurs) afin de faciliter la spécification, l’analyse et le déploiement d’applications dans des architectures P2P. Cette approche incorpore : i) Un langage formel nommé DDF (de l’anglais Data-Dependency Formalism) pour spécifier les applications et construire leurs graphes de dépendances de données. Un graphe de dépendances de données est nommé DDG (de l’anglais Data Dependency Graph) et est défini pour être une représentation abstraite de l’application spécifiée. Ii) Une méthode d’analyse qui utilise le graphe de dépendances de données pour inférer et calculer diverses propriétés, y compris certaines propriétés que les models-checkers ne peuvent pas calculer si le système présente un comportement récursif. Iii) Un intergiciel nommé SON (de l’anglais Shared Data Overlay Network) afin de développer et d’exécuter des applications dans une architecture P2P sans faire face à la complexité des couches sous-jacentes. Cela grâce essentiellement au couplage faible (par une approche orientée services) et à la fonctionnalité de génération de code automatique<br>Developing Peer-to-Peer (P2P) applications became increasingly important in software development. Nowadays, a large number of organizations from many different sectors and sizes depend more and more on collaboration between actors (individuals, groups, communities, etc. ) to perform their tacks. These P2P applications usually have a recursive behaviour that many modeling approaches cannot describe and analyze (e. G. Finite-state approaches). Another challenging issue in P2P application development is the tight coupling between application specification and the underlying P2P technologies and protocols. This forces software developers to make tedious efforts in finding and understanding detailed knowledge about P2P low level concerns. Moreover, this tight coupling constraints applications to run in a changeless runtime environment. Consequently, choosing (for example) another protocol at runtime to meet a new requirement becomes very difficult. Besides these previous issues, P2P applications are usually specified with a weak ability to delegate computing activities between peers, and especially focus on data sharing and storage. Thus, it is not able to take full advantages of the computing power of the underlying P2P network. In this thesis, we present an approach that combines component – and service-oriented development with well-understood methods and techniques from the fields of Attribute Grammars and Data-Flow Analysis (commonly used in compiler construction) in order to offer greater ease in the specification, analysis and deployment of applications ion P2P architecture. This approach embodies : i) A formal language called DDF (Data-Dependency Formalism) to specify applications and construct their Data-Dependency Graphs (DDGs). A DDG has been defined to be an abstract representation of applications. Ii) An analysis method that uses DDG to infer and compute various properties, including some properties that model checkers cannot compute if the system presents recursive behaviour. Iii) A component-based service middleware called SON (Shared-data Overlay Network) to develop and execute applications within P2P architecture without the stress of dealing with P2P low level complexity. Thanks to SON’s automatic generation
42
Temate, Ngaffo Suzy Hélène Germaine. "Des langages de modélisation dédiés aux environnements de méta-modélisation dédiés." Thesis, Toulouse, INPT, 2012. http://www.theses.fr/2012INPT0129/document.
Full textAbstract:
Les langages dédiés (DSL) sont de plus en plus utilisés parce qu’ils permettent aux utilisateurs qui ne sont pas des experts en programmation d’exprimer des solutions avec des langages simples qui capturent l’expertise de leur domaine. C’est encore plus vrai pour les langages dédiés graphiques (DSML) qui ont un niveau d’abstraction plus élevé que les langages dédiés de programmation. Implémenter un DSML revient généralement à fournir un éditeur dédié qui permette aux utilisateurs de manipuler les abstractions de leur domaine (d’instancier le langage). Les expériences ont montré que l’implémentation d’un tel éditeur dédié graphique est coûteuse en termes de temps et de ressources humaines. Nous constatons que la plupart des plates-formes permettant de construire ce type d’éditeur (EMF/GMF, DSL Tools, Obeo Designer, ...) sont génériques. Elles essayent d’adresser le maximum de domaines possibles, ce qui les rend complexes et inadaptées à des cas d’utilisation spécifiques. Si la spécialisation aux domaines a été un succès pour les langages, pourquoi ne pas l’appliquer aux plates-formes de construction d’éditeurs ? Cela reviendrait à concevoir pour un domaine donné, une plate-forme permettant de construire facilement des éditeurs dédiés pour ce domaine. Cette plate-forme n’aurait pas les défauts d’une plate-forme totalement générique parce qu’elle serait restreinte au domaine ciblé. Ce type de plate-forme spécifique à un domaine, nous l’appelons Domain Specific Modeling Framework (DSMF). Le principal inconvénient d’un DSMF est qu’on ne peut l’utiliser que dans le cadre du domaine pour lequel il a été conçu. Cela implique qu’il faille construire un DSMF par domaine et c’est une solution coûteuse. Toutefois, nous pensons que cette approche sur les DSMF peut être généralisée afin d’adresser un grand nombre de domaines. Cette thèse a donc consisté à concevoir et à implanter un environnement qui permet de construire des DSMF de façon modulaire<br>Domain Specific Languages (DSLs) are increasingly used in many fields as they allow users to express strategies without being programming experts. This is particularly true for graphical DSLs called Domain Specific Modeling Languages (DSMLs) which are more intuitive than programming DSLs. Implementing a DSML means providing a specific editor which allow users to express the language’s constructions (instantiate the language). Many experiments showed that implementing specific graphical editors is much manpower consuming. Our analysis is that most frameworks for building such editors (e.g. EMF/GMF) are generic, i.e. aim at fulfilling the requirements of any field, which leads to increased complexity and costs a lot in terms of development time. If domain specialization was successful for languages, why don’t we apply it to frameworks ? Specializing such a framework according to the constraints of a domain would allow keeping the definition of a specific editor simple, while fulfilling the requirements of the considered domain. Domain specific frameworks for building DSML editors in specific application fields is a promising approach. Such a framework does not have the limits of generic frameworks because it is restricted to a particular domain. It is more intuitive and simpler to use as it only proposes abstraction of the domain for building DSMLs. We call this type of framework Domain Specific Modeling Framework (DSMF). For example, if we consider the component domain, there are several DSMLs in this domain which share the same layout requirements. We implemented a DSMF for this family of DSMLs. This DSMF is specialized according to the constraints and layout requirements of the component domain (Components, connectors, Bindings, . . .). This specialization allows simple and rapid generation of specific editors devoted to component-based architectures. The principal drawback of a DSMF is its restricted scope to one specific domain. This approach requires to develop one DSMF per domain and the development cost can be significant. A solution may be to generalise the DSMF approach in order to address many application fields. We designed a Generic framework for building DSMFs in a modular way. This thesis is based on the implementation of this framework
43
Lyon, Eduardo. "Component based design and digital manufacturing: a design for manufacturing model for curved surfaces fabrication using three axes computer numerical controlled router." Diss., Georgia Institute of Technology, 2007. http://hdl.handle.net/1853/36531.
Full textAbstract:
This thesis explores new ways to integrate manufacturing processes information in to design phases. Through the use of design for manufacturing (DfM) concept, and looking at relations between its potential application in architectural production and its implementation using digital manufacturing technologies, the author implemented a DfM model that varies from previous models by incorporated learning in the process. This process was based on the incremental development and refinement of design heuristics and metrics.
The DfM model developed in this research is a process model to be implemented as a framework within educational settings. The proposed model is based in two basic strategies; first a process description in the form of alternative design strategies; and second, the implementation of design heuristics and design metrics. Subsequently, the author tested and refined the model using a sequence of case studies with students.
In the final stage, the research evaluated and further developed the DfM model in a component design case study. The general purpose in performing this case studies sequence was to test the proposed DfM model. The second objective was to refine the DfM model by capturing knowledge from the case studies.
As a summary, this research conceptualizes from this top-down development approach to create a design for manufacturing model that integrates design and construction in architecture, based on three possible applications fields; DfM teaching approaches development, design processes improvement; and DfM methods development.
The final purpose is to provide better foundational constructs for architectural education and to improve teaching approaches that integrate design and manufacturing.
44
Ridikaitė, Milda. "Metaprojektavimo aspektų realizavimas pakartotinio naudojimo technologija grindžiamose informacinėse sistemose." Master's thesis, Lithuanian Academic Libraries Network (LABT), 2007. http://vddb.library.lt/obj/LT-eLABa-0001:E.02~2007~D_20070816_142632-62585.
Full textAbstract:
Dokumento tikslas yra pristatyti pakartotinio panaudojimo technologijos, komponentais grįsto projektavimo ir metaprojektavimo aspektų simbiozės. Simbiozė realizuojama per programinės įrangos architektūros modelį ir rinkinį pakartotinio panaudojimo komponentų, kurie sukurti įtraukti galutinį vartotoją į programinės įrangos procesą kaip projektuotoją.<br>The aim of this paper is to present symbiosis of reuse technology, component based design and meta-project aspects. Symbiosis occurs through software architectural model and set of reusable components designed to involve end-user to software development process as designer. Theoretical background of specified model is delivered in the beginning sections of this thesis. As experimental solution information system was introduced. System provides a pack of highly configurable and customizable components designed to achieve common tasks. Unexpected or rare tasks are solved by providing extra components, which are developed and integrated to entire system according predefined rules. Several complete definitions and application areas of those components are given. Paper also includes statistics about reusable component life cycle in different software projects: how often they are reused and for what purpose. Thesis is concluded with pros and cons of suggested model.
45
Capdevila, Ibañez Bruno. "Serious game architecture and design : modular component-based data-driven entity system framework to support systemic modeling and design in agile serious game developments." Paris 6, 2013. http://www.theses.fr/2013PA066727.
Full textAbstract:
Depuis une dizaine d’années, on constate que les propriétés d’apprentissage inhérentes aux jeux-vidéo incitent de nombreux développeurs à explorer leur potentiel en tant que moyen d’expression pour des buts divers et innovateurs (sérieux). L’apprentissage est au cœur de l’expérience de jeu, mais il prend normalement place dans les domaines affectifs et psychomoteurs. Quand l’apprentissage cible un contenu sérieux, des designers cognitifs/pédagogiques doivent veiller à son effectivité dans le domaine cognitif. Dans des équipes éminemment multidisciplinaires (jeu, technologie, cognition et art), la compréhension et la communication sont indispensables pour une collaboration efficace dès la première étape de conception. Dans une approche génie logiciel, on s’intéresse aux activités (multidisciplinaires) du processus de développement plutôt qu’aux disciplines elles-mêmes, dans le but d’uniformiser et clarifier le domaine. Puis, nous proposons une fondation logicielle qui renforce ce modèle multidisciplinaire grâce à une approche d’underdesign qui favorise la création des espaces de design collaboratifs. Ainsi, Genome Engine peut être vu comme une infrastructure sociotechnique dirigée-donnée qui permet à des développeurs non-programmeurs, comme le game designer et éventuellement le designer cognitif, de participer activement dans la construction du design du produit, plutôt que de l’évaluer déjà en temps d’utilisation. Son architecture est fondée sur un style de système de systèmes d’entités, ce qui contribue à sa modularité, sa réutilisabilité et adaptabilité, ainsi qu’à fournir des abstractions qui favorisent la communication. Plusieurs projets réels nous ont permis de tester notre approche<br>For the last ten years, we witness how the inherent learning properties of videogames entice several creators into exploring their potential as a medium of expression for diverse and innovative (serious) purposes. Learning is at the core of the play experience, but it usually takes place at the affective and psychomotor domains. When the learning targets the serious content, cognitive/instructional designers must ensure its effectiveness at the cognitive domain. In such eminently multidisciplinary teams (game, technology, cognition, art), understanding and communication are essential for an effective collaboration from the early stage of inception. In a software engineering approach, we focus on the (multidisciplinary) activities of the development process rather than the disciplines themselves, with the intent to uniform and clarify the field. Then, we propose a software foundation that reinforces this multidisciplinary model thanks to an underdesign approach that favors the creation of collaborative design workspaces. Thereby, Genome Engine can be considered as a data-driven sociotechnical infrastructure that provides non-programmer developers, such as game designers and eventually cognitive designers, with a means to actively participate in the construction of the product design, rather than evaluating it once in usage time. Its architecture is based on a component-based application framework with an entity system of systems runtime object model, which contributes to modularity, reuse and adaptability, as well as to provide familiar abstractions that ease communication. Our approach has been extensively evaluated with the development of several serious game projects
46
Toresson, Gabriel. "Documenting and Improving the Design of a Large-scale System." Thesis, Linköpings universitet, Programvara och system, 2019. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-157733.
Full textAbstract:
As software systems become increasingly larger and more complex, the need to make them easily maintained increases, as large systems are expected to last for many years. It has been estimated that system maintenance is a large part of many IT-departments’ software development costs. In order to design a complex system to be maintainable it is necessary to introduce structure, often as models in the form of a system architecture and a system design. As development of complex large-scale systems progresses over time, the models may need to be reconstructed. Perhaps because development may have diverted from the initial plan, or because changes had to be made during implementation. This thesis presents a reconstructed documentation of a complex large-scale system, as well as suggestions for how to improve the existing design based on identified needs and insufficiencies. The work was performed primarily using a qualitative manual code review approach of the source code, and the proposal was generated iteratively. The proposed design was evaluated and it was concluded that it does address the needs and insufficiencies, and that it can be realistically implemented.
47
Harbaoui, Ahmed. "Vers une modélisation et un dimensionnement automatique des systèmes répartis." Phd thesis, Université de Grenoble, 2011. http://tel.archives-ouvertes.fr/tel-00649967.
Full textAbstract:
De nos jours, les systèmes distribués sont caractérisés par une complexité croissante de l'architecture, des fonctionnalités et de la charge soumise. Cette complexité induit souvent une perte de la qualité de service offerte, ou une saturation des ressources, voire même l'indisponibilité des services en ligne, en particulier lorsque la charge est importante. Afin d'éviter les désagrèments causés par d'importantes charges et remplir le niveau attendu de la qualité de service, les systèmes nécessitent une auto-gestion, en optimisant par exemple un tier ou en le renforçant à travers la réplication. Cette propriété autonome requiert une modélisation des performances de ces systèmes. Visant cet objectif, nous développons un framework basé sur une méthodologie théorique et expérimentale d'identification automatique de modèle et de dimensionnement, fournissant en premier un modèle de réseau de file d'attente pour un système distribué. Ensuite, ce Modèle est utilisé au sein de notre framwork pour dimensionner le système à travers une analyse ou une simulation du réseau de file d'attente.
48
Persson, Magnus. "Adaptive Middleware for Self-Configurable Embedded Real-Time Systems : Experiences from the DySCAS Project and Remaining Challenges." Licentiate thesis, KTH, Machine Design (Div.), 2009. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-11608.
Full textAbstract:
<p>Development of software for embedded real-time systems poses severalchallenges. Hard and soft constraints on timing, and usually considerableresource limitations, put important constraints on the development. Thetraditional way of coping with these issues is to produce a fully static design,i.e. one that is fully fixed already during design time.Current trends in the area of embedded systems, including the emergingopenness in these types of systems, are providing new challenges for theirdesigners – e.g. integration of new software during runtime, software upgradeor run-time adaptation of application behavior to facilitate better performancecombined with more ecient resource usage. One way to reach these goals is tobuild self-configurable systems, i.e. systems that can resolve such issues withouthuman intervention. Such mechanisms may be used to promote increasedsystem openness.This thesis covers some of the challenges involved in that development.An overview of the current situation is given, with a extensive review ofdi erent concepts that are applicable to the problem, including adaptivitymechanisms (incluing QoS and load balancing), middleware and relevantdesign approaches (component-based, model-based and architectural design).A middleware is a software layer that can be used in distributed systems,with the purpose of abstracting away distribution, and possibly other aspects,for the application developers. The DySCAS project had as a major goaldevelopment of middleware for self-configurable systems in the automotivesector. Such development is complicated by the special requirements thatapply to these platforms.Work on the implementation of an adaptive middleware, DyLite, providingself-configurability to small-scale microcontrollers, is described andcovered in detail. DyLite is a partial implementation of the concepts developedin DySCAS.Another area given significant focus is formal modeling of QoS andresource management. Currently, applications in these types of systems arenot given a fully formal definition, at least not one also covering real-timeaspects. Using formal modeling would extend the possibilities for verificationof not only system functionality, but also of resource usage, timing and otherextra-functional requirements. This thesis includes a proposal of a formalismto be used for these purposes.Several challenges in providing methodology and tools that are usablein a production development still remain. Several key issues in this areaare described, e.g. version/configuration management, access control, andintegration between di erent tools, together with proposals for future workin the other areas covered by the thesis.</p><br><p>Utveckling av mjukvara för inbyggda realtidssystem innebär flera utmaningar.Hårda och mjuka tidskrav, och vanligtvis betydande resursbegränsningar,innebär viktiga inskränkningar på utvecklingen. Det traditionellasättet att hantera dessa utmaningar är att skapa en helt statisk design, d.v.s.en som är helt fix efter utvecklingsskedet.Dagens trender i området inbyggda system, inräknat trenden mot systemöppenhet,skapar nya utmaningar för systemens konstruktörer – exempelvisintegration av ny mjukvara under körskedet, uppgradering av mjukvaraeller anpassning av applikationsbeteende under körskedet för att nå bättreprestanda kombinerat med e ektivare resursutnyttjande. Ett sätt att nå dessamål är att bygga självkonfigurerande system, d.v.s. system som kan lösa sådanautmaningar utan mänsklig inblandning. Sådana mekanismer kan användas föratt öka systemens öppenhet.Denna avhandling täcker några av utmaningarna i denna utveckling. Enöversikt av den nuvarande situationen ges, med en omfattande genomgångav olika koncept som är relevanta för problemet, inklusive anpassningsmekanismer(inklusive QoS och lastbalansering), mellanprogramvara och relevantadesignansatser (komponentbaserad, modellbaserad och arkitekturell design).En mellanprogramvara är ett mjukvarulager som kan användas i distribueradesystem, med syfte att abstrahera bort fördelning av en applikation överett nätverk, och möjligtvis även andra aspekter, för applikationsutvecklarna.DySCAS-projektet hade utveckling av mellanprogramvara för självkonfigurerbarasystem i bilbranschen som ett huvudmål. Sådan utveckling försvåras avde särskilda krav som ställs på dessa plattformarArbete på implementeringen av en adaptiv mellanprogramvara, DyLite,som tillhandahåller självkonfigurerbarhet till småskaliga mikrokontroller,beskrivs och täcks i detalj. DyLite är en delvis implementering av konceptensom utvecklats i DySCAS.Ett annat område som får särskild fokus är formell modellering av QoSoch resurshantering. Idag beskrivs applikationer i dessa områden inte heltformellt, i varje fall inte i den mån att realtidsaspekter täcks in. Att användaformell modellering skulle utöka möjligheterna för verifiering av inte barasystemfunktionalitet, men även resursutnyttjande, tidsaspekter och andraicke-funktionella krav. Denna avhandling innehåller ett förslag på en formalismsom kan användas för dessa syften.Det återstår många utmaningar innan metodik och verktyg som är användbarai en produktionsmiljö kan erbjudas. Många nyckelproblem i områdetbeskrivs, t.ex. versions- och konfigurationshantering, åtkomststyrning ochintegration av olika verktyg, tillsammans med förslag på framtida arbete iövriga områden som täcks av avhandlingen.</p><br>DySCAS
49
Pham, Van Cam. "Model-Based Software Engineering : Methodologies for Model-Code Synchronization in Reactive System Development." Thesis, Université Paris-Saclay (ComUE), 2018. http://www.theses.fr/2018SACLS611/document.
Full textAbstract:
Model-Based Software Engineering (MBSE) a été proposé comme une méthodologie prometteuse de développement de logiciels pour surmonter les limites de la méthodologie traditionnelle basée sur la programmation pour faire face à la complexité des systèmes embarqués. MBSE favorise l’utilisation de langages de modélisation pour décrire les systèmes d’une manière abstraite et fournit des moyens pour générer automatiquement de différents artefacts de développement, p.ex. code et documentation, à partir de modèles. Le développement d’un système complexe implique souvent de multiples intervenants qui utilisent différents outils pour modifier les artefacts de développement, le modèle et le code en particulier dans cette thèse. Les modifications apportées aux artefacts évoquent le problème de cohérence qui nécessite un processus de synchronisation pour propager les modifications apportées dans l’un artefact aux autres artefacts. Dans cette étude, le problème de la synchronisation des modèles d’architecture basés sur les éléments UML composite structure (UML-CS) et UML state machine (UML-SM) du langage de l’Unified Modeling Language (UML), et le code orienté objet est présenté. UML-CSs sont utilisés pour décrire l’architecture du logiciel basée sur les composants et UML-SMs pour les comportements discrets liés aux événements des systèmes réactifs. Le premier défi est de permettre une collaboration entre les architectes de logiciels et les programmeurs produisant de modèle et de code, en utilisant différents outils. Il soulève le problème de synchronisation où il existe de modifications simultanées des artefacts. En fait, il existe un écart de perception entre les langages à base de diagramme (langages de modélisation) et les langages textuels (langages de programmation). D’une part, les programmeurs préfèrent souvent utiliser la combinaison familière d’un langage de programmation et d’un environnement de développement intégré. D’autre part, les architectes logiciels, travaillant à des niveaux d’abstraction plus élevés, favorisent l’utilisation des modèles et préfèrent donc les langages à base de diagramme pour décrire l’architecture du système. Le deuxième défi est qu’il existe un écart d’abstraction significatif entre les éléments du modèle et les éléments du code: les éléments UML-CS et UML-SM sont au niveau d’abstraction plus élevé que les éléments du code. L’écart rend la difficulté pour les approches de synchronisation actuelles car il n’y a pas de façon facile de réflecter les modifications du code au modèle. Cette thèse propose une approche automatisée de synchronisation composée de deux principales contributions corrélées. Pour aborder le premier défi, on propose un patron méthodologique générique de synchronisation entre modèle et code. Il consiste en des définitions des fonctionnalités nécessaires et plusieurs processus qui synchronisent le modèle et le code en fonction de plusieurs scénarios définis où les développeurs utilisent différents outils pour modifier le modèle et le code. Cette contribution est indépendante de UML-CSs et UML-SMs. La deuxième contribution traite du deuxième défi et est basée sur les résultats de la première contribution. Dans la deuxième contribution, un mapping bidirectionnel est présentée pour réduire l’écart d’abstraction entre le modèle et le code. Le mapping est un ensemble de correspondances entre les éléments de modèle et ceux de code. Il est utilisé comme entrée principale du patron méthodologique générique de synchronisation entre modèle et code. Plus important, l’utilisation du mapping fournit les fonctionnalités définies dans la première contribution et facilite la synchronisation des éléments de UML-CS et UML-SM et du code. L’approche est évaluée au moyen de multiples simulations et d’une étude de cas<br>Model-Based Software Engineering (MBSE) has been proposed as a promising software development methodology to overcome limitations of traditional programming-based methodology in dealing with the complexity of embedded systems. MBSE promotes the use of modeling languages for describing systems in an abstract way and provides means for automatically generating different development artifacts, e.g. code and documentation, from models. The development of a complex system often involves multiple stakeholders who use different tools to modify the development artifacts, model and code in particular in this thesis. Artifact modifications must be kept consistent: a synchronization process needs to propagate modifications made in one artifact to the other artifacts. In this study, the problem of synchronizing Unified Modeling Language (UML)-based architecture models, specified by UML composite structure (UML-CS) and UML state machine (UML-SM) elements, and object-oriented code is presented. UML-CSs are used for describing the component-based software architecture and UML-SMs for discrete event-driven behaviors of reactive systems. The first challenge is to enable a collaboration between software architects and programmers producing model and code by using different tools. This raises the synchronization problem of concurrent artifact modifications. In fact, there is a perception gap between diagram-based languages (modeling languages) and text-based languages (programming languages). On the one hand, programmers often prefer to use the more familiar combination of a programming language and an Integrated Development Environment. On the other hand, software architects, working at higher levels of abstraction, tend to favor the use of models, and therefore prefer diagram-based languages for describing the architecture of the system. The second challenge is that there is a significant abstraction gap between the model elements and the code elements: UML-CS andUML-SM elements are at higher level of abstraction than code elements. The gap makes current synchronization approaches hard to be applied since there is no easy way to reflect modifications in code back to model. This thesis proposes an automated synchronization approach that is composed of two main correlated contributions. To address the first challenge, a generic model-code synchronization methodological pattern is proposed. It consists of definitions of necessary functionalities and multiple processes that synchronize model and code based on several defined scenarios where the developers use different tools to modify model and code. This contribution is independent of UML-CSs and UML-SMs. The second contribution deals with the second challenge and is based on the results from the first contribution. In the second contribution, a bidirectional mapping is presented for reducing the abstraction gap between model and code. The mapping is a set of correspondences between model elements and code elements. It is used as main input of the generic model-code synchronization methodological pattern. More importantly, the usage of the mapping provides the functionalities defined in the first contribution and eases the synchronization of UML-CS and UML-SM elements and code. The approach is evaluated by means of multiple simulations and a case study
50
Pathni, Charu. "Round-trip engineering concept for hierarchical UML models in AUTOSAR-based safety projects." Master's thesis, Universitätsbibliothek Chemnitz, 2015. http://nbn-resolving.de/urn:nbn:de:bsz:ch1-qucosa-187153.
Full textAbstract:
Product development process begins at a very abstract level of understanding the requirements. The data needs to be passed on the next phase of development. This happens after every stage for further development and finally a product is made. This thesis deals with the data exchange process of software development process in specific. The problem lies in handling of data in terms of redundancy and versions of the data to be handled. Also, once data passed on to next stage, the ability to exchange it in reveres order is not existent in evident forms. The results found during this thesis discusses the solutions for the problem by getting all the data at same level, in terms of its format. Having the concept ready, provides an opportunity to use this data based on our requirements. In this research, the problem of data consistency, data verification is dealt with. This data is used during the development and data merging from various sources. The concept that is formulated can be expanded to a wide variety of applications with respect to development process. If the process involves exchange of data - scalability and generalization are the main foundation concepts that are contained within the concept.