Conecte-se

Bibliografias temáticas / Software architecture consistency

Literatura científica selecionada sobre o tema "Software architecture consistency"

Autor: Grafiati

Publicado: 23 de junho de 2021

Última modificação: 9 de fevereiro de 2022

Crie uma referência precisa em APA, MLA, Chicago, Harvard, e outros estilos

Selecione um tipo de fonte:

Consulte a lista de atuais artigos, livros, teses, anais de congressos e outras fontes científicas relevantes para o tema "Software architecture consistency".

Ao lado de cada fonte na lista de referências, há um botão "Adicionar à bibliografia". Clique e geraremos automaticamente a citação bibliográfica do trabalho escolhido no estilo de citação de que você precisa: APA, MLA, Harvard, Chicago, Vancouver, etc.

Você também pode baixar o texto completo da publicação científica em formato .pdf e ler o resumo do trabalho online se estiver presente nos metadados.

Índice

Artigos de revistas
Teses / dissertações
Capítulos de livros
Trabalhos de conferências

Artigos de revistas sobre o assunto "Software architecture consistency":

1

Yu, Haobo, Lee Breslau e Scott Shenker. "A scalable Web cache consistency architecture". ACM SIGCOMM Computer Communication Review 29, n.º 4 (outubro de 1999): 163–74. http://dx.doi.org/10.1145/316194.316219.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

2

Lafaye, Jean-Yves, e Georges Louis. "A metric for evaluating software architecture and communication models consistency". RAIRO - Theoretical Informatics and Applications 39, n.º 2 (abril de 2005): 361–90. http://dx.doi.org/10.1051/ita:2005023.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

3

Zhou, Xue Yao, Ning Jiang Chen e Dan Dan Hu. "Behavior Consistency Verification for Evolution of Aspectual Component-Based Software". Advanced Materials Research 765-767 (setembro de 2013): 1231–35. http://dx.doi.org/10.4028/www.scientific.net/amr.765-767.1231.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Aspect-Oriented Software Architecture (AOA) is a high-level abstraction and integration blueprint of aspectual component-based software. A semantic model of aspectual component-based software is proposed to provide behavior description and semantic foundation for the consistency verification of software architecture dynamic evolution. By using the semantic model of Pi-calculus, a set of the consistency verification methods of dynamic evolution from multiple aspects are introduced. Finally, a case study shows the effect of these methods.

4

Heckel, R., e G. Engels. "Relating functional requirements and software architecture: separation and consistency of concerns". Journal of Software Maintenance and Evolution: Research and Practice 14, n.º 5 (2002): 371–88. http://dx.doi.org/10.1002/smr.261.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

5

Ali, Nour, Sean Baker, Ross O’Crowley, Sebastian Herold e Jim Buckley. "Erratum to: Architecture consistency: State of the practice, challenges and requirements". Empirical Software Engineering 23, n.º 3 (14 de setembro de 2017): 1868–69. http://dx.doi.org/10.1007/s10664-017-9542-0.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

6

Elzain e Wu. "Software Defined Wireless Mesh Network Flat Distribution Control Plane". Future Internet 11, n.º 8 (25 de julho de 2019): 166. http://dx.doi.org/10.3390/fi11080166.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Wireless Mesh Networks (WMNs), have a potential offering relatively stable Internet broadband access. The rapid development and growth of WMNs attract ISPs to support users’ coverage anywhere anytime. To achieve this goal network architecture must be addressed carefully. Software Defined Networking (SDN) proposes new network architecture for wired and wireless networks. Software Defined Wireless Networking (SDWN) has a great potential to increase efficiency, ease the complexity of control and management, and accelerate technology innovation rate of wireless networking. An SDN controller is the core component of an SDN network. It needs to have updated reports of the network status change, as in network topology and quality of service (QoS) in order to effectively configure and manage the network it controls. In this paper, we propose Flat Distributed Software Defined Wireless Mesh Network architecture where the controller aggregates entire topology discovery and monitors QoS properties of extended WMN nodes using Link Layer Discovery Protocol (LLDP) protocol, which is not possible in multi-hop ordinary architectures. The proposed architecture has been implemented on top of POX controller and Advanced Message Queuing Protocol (AMQP) protocol. The experiments were conducted in a Mininet-wifi emulator, the results present the architecture control plane consistency and two application cases: topology discovery and QoS monitoring. The current results push us to study QoS-routing for video streaming over WMN.

7

Dambietz, Florian M., Christoph Rennpferdt, Michael Hanna e Dieter Krause. "Using MBSE for the Enhancement of Consistency and Continuity in Modular Product-Service-System Architectures". Systems 9, n.º 3 (17 de agosto de 2021): 63. http://dx.doi.org/10.3390/systems9030063.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Within emerging markets, ensuring the competitiveness of manufacturing companies is crucial to their success. The integration of new business possibilities, such as Product-Service-Systems (PSS) can provide one suitable solution. Especially within the architecture development process, large amounts of interconnected data and data types need to be processed and versioned. This leads to a significant lack of data consistency and continuity along the development process of modular PSS architectures. This lack of consistency and continuity leads to a process being prone to errors, representing a significant negative impact onto the company’s value-added stream. We provide one possible solution to these issues by presenting a PSS architecture modularization approach based upon the modularization methods of the Integrated PKT-Approach. Using concepts of Model-Based Systems Engineering (MBSE) for modelling these architectures, automated and dynamic analyses of the architecture for the iteration and harmonization of the PSS architecture under development are enabled. The at first generically described approach is further detailed in the second part of this contribution by applying it to an industry case study for mobile laser welding systems. As a result, a clear support for the visualization of architecture iteration aspects as well as for the enhancement of data consistency and continuity is given.

8

Wang, Yongdong, e Lawrence A. Rowe. "Cache consistency and concurrency control in a client/server DBMS architecture". ACM SIGMOD Record 20, n.º 2 (abril de 1991): 367–76. http://dx.doi.org/10.1145/119995.115855.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

9

Zhang, Yang, Shixin Sun, Dongwen Zhang, Jing Qiu e Zhihong Tian. "A consistency-guaranteed approach for Internet of Things software refactoring". International Journal of Distributed Sensor Networks 16, n.º 1 (janeiro de 2020): 155014772090168. http://dx.doi.org/10.1177/1550147720901680.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

The software architecture of Internet of Things defines the component model and interconnection topology of Internet of Things systems. Refactoring is a systematic practice of improving a software structure without altering its external behaviors. When the Internet of Things software is refactored, it is necessary to detect the correctness of Internet of Things software to ensure its security. To this end, this article proposes a novel refactoring correction detection approach to ensure software security. Control flow analysis and data flow analysis are used to detect code changes before and after refactoring, and synchronization dependency analysis is used to detect changes in synchronization dependency. Three detection algorithms are designed to detect refactoring correctness. Four real-world benchmark applications are used to evaluate our approach. The experimental results show that our proposed approach can ensure correctness of Internet of Things software refactoring.

10

Park, Woo-Chan, Cheong-Ghil Kim, Duk-Ki Yoon, Kil-Whan Lee, Il-San Kim e Tack-Don Han. "A consistency-free memory architecture for sort-last parallel rendering processors". Journal of Systems Architecture 53, n.º 5-6 (maio de 2007): 272–84. http://dx.doi.org/10.1016/j.sysarc.2006.10.010.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Mais fontes

Teses / dissertações sobre o assunto "Software architecture consistency":

1

Smolko, Danila Stanislavovich. "Software agent architecture for consistency checking of distributed documents". Thesis, University College London (University of London), 2002. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.271187.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

2

Florean, Alexander, e Laoa Jalal. "Mapping Java Source Code To Architectural Concerns Through Machine Learning". Thesis, Karlstads universitet, Institutionen för matematik och datavetenskap (from 2013), 2021. http://urn.kb.se/resolve?urn=urn:nbn:se:kau:diva-84250.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

The explosive growth of software systems with both size and complexity results in the recognised need of techniques to combat architectural degradation. Reflexion Modelling is a method commonly used for Software Architectural Consistency Checking (SACC). However, the steps needed to utilise the method involve manual mapping, which could become tedious depending on the system's size. Recently, machine learning has been showing promising results outperforming other approaches. However, neither a comparison of different classifiers nor a comprehensive investigation of how to best pre-process source code has yet been performed. This thesis compares different classifier and their performance to the manual effort needed to train them and how different pre-processing settings affect their accuracy. The study can be divided into two areas: pre-processing and how large the manual mapping should be to achieve satisfactory performance. Across the three software systems used in this study, the overall best performing model, MaxEnt, achieved the following average results, accuracy 0.88, weighted precision 0.89 and weighted recall 0.88. SVM performed almost identically to MaxEnt. Furthermore, the results show that Naive-Bayes, the algorithm in recent related work approaches, performs worse than SVM and MaxEnt. The results yielded that the pre-processing that extracts packages and libraries, together with the feature representation method Bag-of-Words had the best performance. Furthermore, it was found that manual mapping of a minimum of ten files per concern is needed for satisfactory performance. The research results represent a further step towards automating code-to-architecture mappings, as required in reflexion modelling and similar techniques.

3

Arad, Cosmin Ionel. "Programming Model and Protocols for Reconfigurable Distributed Systems". Doctoral thesis, KTH, Programvaruteknik och Datorsystem, SCS, 2013. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-122311.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Distributed systems are everywhere. From large datacenters to mobile devices, an ever richer assortment of applications and services relies on distributed systems, infrastructure, and protocols. Despite their ubiquity, testing and debugging distributed systems remains notoriously hard. Moreover, aside from inherent design challenges posed by partial failure, concurrency, or asynchrony, there remain significant challenges in the implementation of distributed systems. These programming challenges stem from the increasing complexity of the concurrent activities and reactive behaviors in a distributed system on the one hand, and the need to effectively leverage the parallelism offered by modern multi-core hardware, on the other hand. This thesis contributes Kompics, a programming model designed to alleviate some of these challenges. Kompics is a component model and programming framework for building distributed systems by composing message-passing concurrent components. Systems built with Kompics leverage multi-core machines out of the box, and they can be dynamically reconfigured to support hot software upgrades. A simulation framework enables deterministic execution replay for debugging, testing, and reproducible behavior evaluation for largescale Kompics distributed systems. The same system code is used for both simulation and production deployment, greatly simplifying the system development, testing, and debugging cycle. We highlight the architectural patterns and abstractions facilitated by Kompics through a case study of a non-trivial distributed key-value storage system. CATS is a scalable, fault-tolerant, elastic, and self-managing key-value store which trades off service availability for guarantees of atomic data consistency and tolerance to network partitions. We present the composition architecture for the numerous protocols employed by the CATS system, as well as our methodology for testing the correctness of key CATS algorithms using the Kompics simulation framework. Results from a comprehensive performance evaluation attest that CATS achieves its claimed properties and delivers a level of performance competitive with similar systems which provide only weaker consistency guarantees. More importantly, this testifies that Kompics admits efficient system implementations. Its use as a teaching framework as well as its use for rapid prototyping, development, and evaluation of a myriad of scalable distributed systems, both within and outside our research group, confirm the practicality of Kompics.

QC 20130520

4

Arad, Cosmin. "Programming Model and Protocols for Reconfigurable Distributed Systems". Doctoral thesis, SICS, 2013. http://urn.kb.se/resolve?urn=urn:nbn:se:ri:diva-24202.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Distributed systems are everywhere. From large datacenters to mobile devices, an ever richer assortment of applications and services relies on distributed systems, infrastructure, and protocols. Despite their ubiquity, testing and debugging distributed systems remains notoriously hard. Moreover, aside from inherent design challenges posed by partial failure, concurrency, or asynchrony, there remain significant challenges in the implementation of distributed systems. These programming challenges stem from the increasing complexity of the concurrent activities and reactive behaviors in a distributed system on the one hand, and the need to effectively leverage the parallelism offered by modern multi-core hardware, on the other hand. This thesis contributes Kompics, a programming model designed to alleviate some of these challenges. Kompics is a component model and programming framework for building distributed systems by composing message-passing concurrent components. Systems built with Kompics leverage multi-core machines out of the box, and they can be dynamically reconfigured to support hot software upgrades. A simulation framework enables deterministic execution replay for debugging, testing, and reproducible behavior evaluation for large-scale Kompics distributed systems. The same system code is used for both simulation and production deployment, greatly simplifying the system development, testing, and debugging cycle. We highlight the architectural patterns and abstractions facilitated by Kompics through a case study of a non-trivial distributed key-value storage system. CATS is a scalable, fault-tolerant, elastic, and self-managing key-value store which trades off service availability for guarantees of atomic data consistency and tolerance to network partitions. We present the composition architecture for the numerous protocols employed by the CATS system, as well as our methodology for testing the correctness of key CATS algorithms using the Kompics simulation framework. Results from a comprehensive performance evaluation attest that CATS achieves its claimed properties and delivers a level of performance competitive with similar systems which provide only weaker consistency guarantees. More importantly, this testifies that Kompics admits efficient system implementations. Its use as a teaching framework as well as its use for rapid prototyping, development, and evaluation of a myriad of scalable distributed systems, both within and outside our research group, confirm the practicality of Kompics.
Kompics
CATS
REST

5

Lopes, André Filipe da Rocha. "tlCell: a software transactional memory for the cell broadband engine architecture". Master's thesis, Faculdade de Cencias e Tecnologia, 2010. http://hdl.handle.net/10362/4110.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Dissertação apresentada na Faculdade de Ciências e Tecnologia da Universidade Nova de Lisboa para a obtenção do Grau de Mestre em Engenharia Informática
Os computadores evoluíram exponencialmente na ultima década. A performance tem sido o principal objectivo resultando no aumento do frequência dos processadores, situação que já não é fazível devido ao consumo de energia exagerado dos processadores actuais. A arquitectura Cell Broadband Engine começou com o objectivo de providenciar alta capacidade computacional com um baixo consumo energético. O resultado é uma arquitectura com multiprocessadores heterogéneos e uma distribuição de memória única com vista a alto desempenho e redução da complexidade do hardware para reduzir o custo de produção. Espera-se que as técnicas de concorrência e paralelismo aumentem a performance desta arquitectura, no entanto as soluções de alto desempenho apresentadas s˜ao sempre muito especificas e devido à sua arquitectura e distribuição de memória inovadora ´e ainda difícil apresentar ferramentas passíveis de explorar concorrência e paralelismo como um camada de abstracção. Memória Transaccional por Software é um modelo de programação que propõe este nível de abstracção e tem vindo a ganhar popularidade existindo já variadas implementações com performance perto de soluções específicas de grão fino. A possibilidade de usar Memória Transaccional por Software nesta arquitectura inovadora, desenvolvendo uma ferramenta capaz de abstrair o programador da consistência e gestão de memória é apelativo. Neste documento especifica-se uma plataforma deffered-update de Memória Transactional por Software para a arquitectura Cell Broadband Engine que tira partido da capacidade computacional dos Synergistic Processing Elements (SPEs) usando locks em commit-time. São propostos dois modelos diferentes, fully local e multi-buffered de forma a poder estudar as implicações das escolhas feitas no desenho da plataforma.

6

Gadea, Cristian. "Architectures and Algorithms for Real-Time Web-Based Collaboration". Thesis, Université d'Ottawa / University of Ottawa, 2021. http://hdl.handle.net/10393/41944.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Originating in the theory of distributed computing, the optimistic consistency control method known as Operational Transformation (OT) has been studied by researchers since the late 1980s. Algorithms were devised for managing the concurrent nature of user actions and for maintaining the consistency of replicated data as changes are introduced by multiple geographically-distributed users in real-time. Web-Based Collaborative Platforms are now essential components of modern organizations, with real-time protocols and standards such as WebSocket enabling the development of online collaboration tools to facilitate information sharing, content creation, document management, audio and video streaming, and communication among team members. Products such as Google Docs have shown that centralized web-based co-editing is now possible in a reliable way, with benefits in user productivity and efficiency. However, as the demand for effective real-time collaboration between team members continues to increase, web applications require new synchronization algorithms and architectures to resolve the editing conflicts that may appear when multiple individuals are modifying the same data at the same time. In addition, collaborative applications need to be supported by scalable distributed backend services, as can be achieved with "serverless" technologies. While much existing research has addressed problems of optimistic consistency maintenance, previous approaches have not focused on capturing the dynamic client-server interactions of OT systems by modeling them as real-time systems using Finite State Machine (FSM) theory. This thesis includes an exploration of how the principles of control theory and hierarchical FSMs can be applied to model the distributed system behavior when processing and transforming HTML DOM changes initiated by multiple concurrent users. The FSM-based OT implementation is simulated, including with random inputs, and the approach is shown to be invaluable for organizing the algorithms required for synchronizing complex data structures. The real-time feedback control mechanism is used to develop a Web-Based Collaborative Platform based on a new OT integration algorithm and architecture that brings "Virtual DOM" concepts together with state-of-the-art OT principles to enable the next generation of collaborative web-based experiences, as shown with implementations of a rich-text editor and a 3D virtual environment.

7

Huynh, Ngoc Tho. "A development process for building adaptative software architectures". Thesis, Ecole nationale supérieure Mines-Télécom Atlantique Bretagne Pays de la Loire, 2017. http://www.theses.fr/2017IMTA0026/document.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Les logiciels adaptatifs sont une classe de logiciels qui peuvent modifier leur structure et comportement à l'exécution afin de s'adapter à des nouveaux contextes d'exécution. Le développement de logiciels adaptatifs a été un domaine de recherche très actif les dix dernières années. Plusieurs approches utilisent des techniques issues des lignes des produits afin de développer de tels logiciels. Ils proposent des outils, des frameworks, ou des langages pour construire des architectures logicielles adaptatives, mais ne guident pas les ingénieurs dans leur utilisation. De plus, ils supposent que tous les éléments spécifiés à la conception sont disponibles dans l'architecture pour l'adaptation, même s'ils ne seront jamais utilisés. Ces éléments inutiles peuvent être une cause de soucis lors du déploiement sur une cible dont l'espace mémoire est très contraint par exemple. Par ailleurs, le remplacement de composants à l'exécution reste une tâche complexe, elle doit assurer non seulement la validité de la nouvelle version, mais aussi préserver la terminaison correcte des transactions en cours. Pour faire face à ces problèmes, cette thèse propose un processus de développement de logiciels adaptatifs où les tâches, les rôles, et les artefacts associés sont explicites. En particulier, le processus vise la spécification d'informations nécessaires pour construire des architectures logicielles adaptatives. Le résultat d'un tel processus est une architecture logicielle adaptative qui contient seulement des éléments utiles pour l'adaptation. De plus, un mécanisme d'adaptation est proposé basé sur la gestion de transactions pour assurer une adaptation dynamique cohérente. Elle assure la terminaison correcte des transactions en cours. Nous proposons pour cela la notion de dépendance transactionnelle : dépendance entre des actions réalisées par des composants différents. Nous proposons la spécification de ces dépendances dans le modèle de variabilité, et de l'exploiter pour décider des fonctions de contrôle dans les composants de l'architecture, des fonctions qui assurent une adaptation cohérente à l'exécution
Adaptive software is a class of software which is able to modify its own internal structure and hence its behavior at runtime in response to changes in its operating environment. Adaptive software development has been an emerging research area of software engineering in the last decade. Many existing approaches use techniques issued from software product lines (SPLs) to develop adaptive software architectures. They propose tools, frameworks or languages to build adaptive software architectures but do not guide developers on the process of using them. Moreover, they suppose that all elements in the SPL specified are available in the architecture for adaptation. Therefore, the adaptive software architecture may embed unnecessary elements (components that will never be used) thus limiting the possible deployment targets. On the other hand, the components replacement at runtime remains a complex task since it must ensure the validity of the new version, in addition to preserving the correct completion of ongoing activities. To cope with these issues, this thesis proposes an adaptive software development process where tasks, roles, and associate artifacts are explicit. The process aims at specifying the necessary information for building adaptive software architectures. The result of such process is an adaptive software architecture that only contains necessary elements for adaptation. On the other hand, an adaptation mechanism is proposed based on transactions management for ensuring consistent dynamic adaptation. Such adaptation must guarantee the system state and ensure the correct completion of ongoing transactions. In particular, transactional dependencies are specified at design time in the variability model. Then, based on such dependencies, components in the architecture include the necessary mechanisms to manage transactions at runtime consistently

8

Gao, Yan. "Multi-view consistency checking of BON software description diagrams /". 2004. http://gateway.proquest.com/openurl?url%5Fver=Z39.88-2004&res%5Fdat=xri:pqdiss&rft%5Fval%5Ffmt=info:ofi/fmt:kev:mtx:dissertation&rft%5Fdat=xri:pqdiss:MQ99311.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Thesis (M.Sc.)--York University, 2004. Graduate Programme in Computer Science.
Typescript. Includes bibliographical references (leaves 130-134). Also available on the Internet. MODE OF ACCESS via web browser by entering the following URL:http://gateway.proquest.com/openurl?url%5Fver=Z39.88-2004&res%5Fdat=xri:pqdiss&rft%5Fval%5Ffmt=info:ofi/fmt:kev:mtx:dissertation&rft%5Fdat=xri:pqdiss:MQ99311

9

Holstein, Tobias. "Towards a Multi-OS Architecture for Consistent User Interface Experience". Licentiate thesis, 2016. http://urn.kb.se/resolve?urn=urn:nbn:se:mdh:diva-33538.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

Vehicles have greatly changed over the last decades. Originally, they were used as a means of transportation, and their drivers were solely engaged in the driving task. In modern cars the user, i.e. the former driver, has to interact with many different systems, which provide access to different domains, such as vehicle functions (monitoring speed, fuel consumption), safety related features, comfort and infotainment. Advancements in technologies make it possible to cope with the increasing amount of features, as for example the introduction of input and output modalities that allow new ways of interaction, such as touch(-screens), voice control or gesture recognition. In the end a user has to interact with all systems through the overall user-interface. This requires a high usability and a consistent look and feel in order to provide a consistent user experience. On the technology side, developers have to cope with rising complexity, dependencies and inter-connections of about 80 different embedded systems in a premium car. The introduction of multi-core systems opened the way for new approaches, like Multi-OS environments. There multiple operating systems are consolidated onto a single hardware platform by the use of hardware/software virtualization. This allows for example to run real-time operating systems (RTOS) for safety critical cluster applications next to a general purpose operating system (GPOS) for infotainment applications. This also poses new challenges, such as the contradiction between a clear separation meant to reduce complexity, dependencies and to mitigate the risk of interferences, and interconnections that are required to create a composited user-interface. In this thesis, the challenges of compositing heterogeneous systems in an automotive context are explored. Current approaches are studied and the contradiction of separation and interconnection is explained. Based on this, concepts are introduced and software architectures are proposed, which can be used to implement composited user interfaces for Multi-OS environments. Furthermore, an application prototype that is used to verify the proposed software architecture in regard of graphical user-interfaces, called HTML-UI-Compositor, has been implemented. The HTML-UI-Compositor also provides a simple way of compositing graphical user-interfaces through the adaptation of a web browser engine, which allows well-known standard web development tools and languages to be used to create composited user-interfaces. Those are the first steps towards a Multi-OS architecture that supports a consistent user interface experience.
Bilen har förändrats mycket under de senaste decennierna. Ursprungligen användes den som ett transportmedel och dess förare var enbart engagerad i att köra fordonet. I moderna bilar måste användaren, det vill säga den tidigare omnämnde föraren, interagera med många olika system, som ger tillgång till olika domäner, såsom fordonsfunktioner (exempelvis övervakning av hastighet och bränsleförbrukning), säkerhetsrelaterade funktioner, komfort funktioner samt information och underhållningssystem (infotainment). Tekniska framsteg gör det möjligt att hantera den ökande mängden funktioner, exempelvis införandet inmatnings- och presentationsmodeller som möjliggör nya sätt att interagera, såsom pek (-skärmar), röststyrning eller rörelsedetektering. Användaren får slutligen interagera med de olika systemen via ett övergripande användargränssnitt . Detta kräver en hög användbarhet samt en enhetlighet i utseende och känsla för att ge en konsistent användarupplevelse. På den tekniska sidan måste utvecklare klara av ökande komplexitet, beroenden och sammanlänkning av olika inbyggda system, cirka 80 i en premiumbil. Införandet av multi-core system öppnade vägen för nya metoder, som Multi-OS miljöer. I dessa miljöer har flera operativsystem konsoliderats till en enda hårdvaruplattform med hjälp av hårdvaru- och mjukvaru-virtualisering. Detta gör det exempelvis möjligt att exekvera realtidsoperativsystem (RTOS) för säkerhetskritiska klusterapplikationer parallellt med ett generellt operativsystem (GPOS) för infotainmentapplikationer. Det innebär också nya utmaningar, såsom motsättningen emellan en tydlig separation, tänkt att minska komplexiteten och risken för störningar, samt de beroenden och sammankopplingar som krävs för att skapa ett sammansatt användargränssnitt. Denna avhandling utforskar utmaningarna för sammansatta heterogena system i en fordonsmiljö. Nuvarande metoder studeras och motsättningen mellan separation och sammankoppling förtydligas. Baserat på detta introduceras koncept samt förslag på mjukvaruarkitekturer som kan användas för att implementera sammansatta användargränssnitt för Multi-OS-miljöer. Vidare har en prototyp, kallad HTML-UI-Compositor, utvecklats för att verifiera den föreslagna mjukvaruarkitekturen, med avseende på grafiska användargränssnitt. Genom en anpassad webbläsarmotor tillhandahåller HTML-UI-Compositor dessutom ett enkelt sätt att sammanfoga grafiska användargränssnitt, vilket gör det möjligt att använda välkända standardverktyg och språk för webbutveckling för att skapa sammansatta användargränssnitt. Dessa är de första stegen mot en Multi-OS arkitektur med stöd för en konsekvent användarupplevelse.

Capítulos de livros sobre o assunto "Software architecture consistency":

1

Herold, Sebastian, e Matthias Mair. "Recommending Refactorings to Re-establish Architectural Consistency". In Software Architecture, 390–97. Cham: Springer International Publishing, 2014. http://dx.doi.org/10.1007/978-3-319-09970-5_33.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

2

Kacem, Najla Hadj, Ahmed Hadj Kacem e Khalil Drira. "A Formal Approach to Enforcing Consistency in Self-adaptive Systems". In Software Architecture, 279–94. Berlin, Heidelberg: Springer Berlin Heidelberg, 2010. http://dx.doi.org/10.1007/978-3-642-15114-9_21.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

3

Surajbali, Bholanathsingh, Paul Grace e Geoff Coulson. "A Consistency Framework for Dynamic Reconfiguration in AO-Middleware Architectures". In Software Architecture, 398–405. Cham: Springer International Publishing, 2014. http://dx.doi.org/10.1007/978-3-319-09970-5_34.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

4

Adersberger, Josef, e Michael Philippsen. "ReflexML: UML-Based Architecture-to-Code Traceability and Consistency Checking". In Software Architecture, 344–59. Berlin, Heidelberg: Springer Berlin Heidelberg, 2011. http://dx.doi.org/10.1007/978-3-642-23798-0_37.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

5

Taylor, Richard N. "Software Architecture, (In)consistency, and Integration". In Engineering of Software, 153–61. Berlin, Heidelberg: Springer Berlin Heidelberg, 2011. http://dx.doi.org/10.1007/978-3-642-19823-6_9.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

6

Lytra, Ioanna, Huy Tran e Uwe Zdun. "Supporting Consistency between Architectural Design Decisions and Component Models through Reusable Architectural Knowledge Transformations". In Software Architecture, 224–39. Berlin, Heidelberg: Springer Berlin Heidelberg, 2013. http://dx.doi.org/10.1007/978-3-642-39031-9_20.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

7

Greifenberg, Timo, Steffen Hillemacher e Katrin Hölldobler. "Applied Artifact-Based Analysis for Architecture Consistency Checking". In Ernst Denert Award for Software Engineering 2019, 61–85. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-58617-1_5.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Resumo:

AbstractThe usage of models within model-driven software development aims at facilitating complexity management of the system under development and closing the gap between the problem and the solution domain. Utilizing model-driven software development (MDD) tools for agile development can also increase the complexity within a project. The huge number of different artifacts and relations, their different kinds, and the high degree of automation hinder the understanding, maintenance, and evolution within MDD projects. A systematic approach to understand and manage MDD projects with a focus on its artifacts and corresponding relations is necessary to handle the complexity. The artifact-based analysis presented in this paper is such an approach. This paper gives an overview of different contributions of the artifact-based analysis but focuses on a specific kind of analysis: architecture consistency checking of model-driven development projects. By applying this kind of analyses, differences between the desired architecture and the actual architecture of the project at a specific point in time can be revealed.

8

Biehl, Matthias, e Welf Löwe. "Automated Architecture Consistency Checking for Model Driven Software Development". In Lecture Notes in Computer Science, 36–51. Berlin, Heidelberg: Springer Berlin Heidelberg, 2009. http://dx.doi.org/10.1007/978-3-642-02351-4_3.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

9

Schenkhuizen, Jasper, Jan Martijn E. M. van der Werf, Slinger Jansen e Lambert Caljouw. "Consistent Inconsistency Management: A Concern-Driven Approach". In Software Architecture, 201–9. Cham: Springer International Publishing, 2016. http://dx.doi.org/10.1007/978-3-319-48992-6_15.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

10

Fradet, Pascal, Daniel Le Métayer e Michaël Périn. "Consistency Checking for Multiple View Software Architectures". In Software Engineering — ESEC/FSE ’99, 410–28. Berlin, Heidelberg: Springer Berlin Heidelberg, 1999. http://dx.doi.org/10.1007/3-540-48166-4_25.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

Trabalhos de conferências sobre o assunto "Software architecture consistency":

1

Galster, Matthias. "Dependencies, traceability and consistency in software architecture". In the 5th European Conference. New York, New York, USA: ACM Press, 2011. http://dx.doi.org/10.1145/2031759.2031761.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

2

Monschein, David, Manar Mazkatli, Robert Heinrich e Anne Koziolek. "Enabling Consistency between Software Artefacts for Software Adaption and Evolution". In 2021 IEEE 18th International Conference on Software Architecture (ICSA). IEEE, 2021. http://dx.doi.org/10.1109/icsa51549.2021.00009.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

3

Greifenberg, Timo, Klaus Müller e Bernhard Rumpe. "Architectural Consistency Checking in Plugin-Based Software Systems". In ECSAW '15: 2015 European Conference on Software Architecture Workshops. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2797433.2797493.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

4

Herold, Sebastian, Martin Blom e Jim Buckley. "Evidence in architecture degradation and consistency checking research". In ECSAW '16: European Conference on Software Architecture Workshops. New York, NY, USA: ACM, 2016. http://dx.doi.org/10.1145/2993412.3003396.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

5

Herold, Sebastian, Jim Buckley e Andreas Rausch. "Second Workshop on Software Architecture Erosion and Architectural Consistency (SAEroCon 2015)". In ECSAW '15: 2015 European Conference on Software Architecture Workshops. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2797433.2797490.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

6

Keim, Jan, e Anne Koziolek. "Towards Consistency Checking Between Software Architecture and Informal Documentation". In 2019 IEEE International Conference on Software Architecture Companion (ICSA-C). IEEE, 2019. http://dx.doi.org/10.1109/icsa-c.2019.00052.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

7

Santos, Gustavo, Nicolas Anquetil, Anne Etien, Stephane Ducasse e Marco Tulio Valente. "OrionPlanning: Improving modularization and checking consistency on software architecture". In 2015 IEEE 3rd Working Conference on Software Visualization (VISSOFT). IEEE, 2015. http://dx.doi.org/10.1109/vissoft.2015.7332435.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

8

"Session details: Fourth workshop on software architecture erosion and architectural consistency (SAEroCon 2017)". In ECSA '17: 11th European Conference on Software Architecture, editado por Jim Buckley, Sebastian Herold e Leo Pruijt. New York, NY, USA: ACM, 2017. http://dx.doi.org/10.1145/3258046.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

9

Kramer, Max E., Michael Langhammer, Dominik Messinger, Stephan Seifermann e Erik Burger. "Change-Driven Consistency for Component Code, Architectural Models, and Contracts". In CompArch '15: Federated Events on Component-Based Software Engineering and Software Architecture. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2737166.2737177.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.

10

Sreeram, Jaswanth, Romain Cledat, Tushar Kumar e Santosh Pande. "RSTM : A Relaxed Consistency Software Transactional Memory for Multicores". In 16th International Conference on Parallel Architecture and Compilation Techniques (PACT 2007). IEEE, 2007. http://dx.doi.org/10.1109/pact.2007.4336256.

Texto completo da fonte

Estilos ABNT, Harvard, Vancouver, APA, etc.