A component- and message-based architectural style for GUI software

Taylor, Richard N.; Medvidović, Nenad; Anderson, Kenneth M.; Whitehead, E. James; Robbins, Jason E.; Nies, Kari; Oreizy, Peyman; Dubrow, Deborah L.

doi:10.1109/32.508313

Cited by 313 publications

(94 citation statements)

References 22 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…In total over ten integration case studies were performed that tested the validity of our approach. For example, Rose was integrated with the UML/Analyzer system for automated consistency checking between UML class diagrams and C2 architectural descriptions (Taylor et al, 1996); it was integrated with an automated class diagrams abstraction software (Egyed, 2002), the SDS Simulator for executing UML-like class and statechart diagrams (Egyed and Wile, 2001) the Boeing/MoBIES Translator and Exporter for modeling embedded systems (Schulte, 2002), and several other systems. Similarly, Matlab/Stateflow and Microsoft PowerPoint were integrated into yet other systems like the Design Editor for modeling user-definable notations or the survey authoring system (Wile, 2001).…”

Section: Validation and Limitationsmentioning

confidence: 99%

Integrating COTS Software into Systems through Instrumentation and Reasoning

Egyed¹,

Balzer²

2006

Autom Software Eng

View full text Add to dashboard Cite

Commercial-off-the-shelf (COTS) software tends to be cheap, reliable, and functionally powerful due to its large user base. It has thus become highly desirable to incorporate COTS software into software products (systems) as it can significantly reduce development cost and effort, while maintaining overall software product quality and increasing product acceptance. However, incorporating COTS software into software products introduces new complexities that developers are currently ill equipped to handle. Most significantly, while COTS software frequently contains programmatic interfaces that allow other software components to obtain services from them on a direct call basis, they usually lack the ability to initiate interactions with other components. This often leads to problems of state and/or data inconsistency. This paper presents a framework for integrating COTS software as proactive components within a software system that maintain the consistency of the state and data they share with other components. The framework utilizes a combination of low-level instrumentation and high-level reasoning to expose the relevant internal activities within a COTS component required to initiate the communication needed to maintain consistency with the other components with which it shares state and data. We will illustrate these capabilities through the integration of IBM's Rational Rose into a design suite and demonstrate how our framework solves the complex data synchronization problems that arise from this integration.

show abstract

Section: Validation and Limitationsmentioning

confidence: 99%

Integrating COTS Software into Systems through Instrumentation and Reasoning

Egyed¹,

Balzer²

2006

Autom Software Eng

View full text Add to dashboard Cite

show abstract

“…The idealised C2 component (iC2C) [9] is another structuring technique based on the idealised faulttolerant component (Subsection 2.2), which focus on software systems compliant with the C2 architectural style [21] . The internal protocol followed by the internal elements of an iC2C enforces error confinement and makes it possible to define multiple exception handling contexts at the architectural level.…”

Section: Related Workmentioning

confidence: 99%

Architecting Fault Tolerance with Exception Handling: Verification and Validation

Brito

Lemos

Rubira

et al. 2009

J. Comput. Sci. Technol.

View full text Add to dashboard Cite

When building dependable systems by integrating untrusted software components that were not originally designed to interact with each other, it is likely the occurrence of architectural mismatches related to assumptions in their failure behaviour. These mismatches, if not prevented during system design, have to be tolerated during runtime. This paper presents an architectural abstraction based on exception handling for structuring fault-tolerant software systems. This abstraction comprises several components and connectors that promote an existing untrusted software element into an idealised fault-tolerant architectural element. Moreover, it is considered in the context of a rigorous software development approach based on formal methods for representing the structure and behaviour of the software architecture. The proposed approach relies on a formal specification and verification for analysing exception propagation, and verifying important dependability properties, such as deadlock freedom, and scenarios of architectural reconfiguration. The formal models are automatically generated using model transformation from UML diagrams: component diagram representing the system structure, and sequence diagrams representing the system behaviour. Finally, the formal models are also used for generating unit and integration test cases that are used for assessing the correctness of the source code. The feasibility of the proposed architectural approach was evaluated on an embedded critical case study.

show abstract

“…Up until now, there are several well-known architecture description languages: C2 [10], UniCon [11], Wright [12], Rapide [13] and ACME [14]. Each of these ADLs supports a specific component model and provides a relatively simple connector mechanism.…”

Section: Related Workmentioning

confidence: 99%

Supporting crosscutting concern modelling in software architecture design

Mei

Cao

Zhou

2007

Front. Comput. Sc. China

View full text Add to dashboard Cite

Crosscutting concerns such as logging, security, and transaction, are well supported in the programming level by aspect-oriented programming technologies. However, addressing these issues in the high-level architecture design still remains open. This paper presents a novel approach to supporting crosscutting concern modelling in the software architecture design of component-based systems. We introduce a new element named "Aspect" into our architecture description language, ABC/ADL, to clearly model the behavior of crosscutting concerns. Aspect is the first class entity as Component and Connector in ABC/ADL. ABC/ADL Connectors provide the weaving points where the component and aspect crosscut. This approach effectively enables "separation of concerns" in high-level architecture design, and facilitates black-box reuse of COTS components.

show abstract

A component- and message-based architectural style for GUI software

Cited by 313 publications

References 22 publications

Integrating COTS Software into Systems through Instrumentation and Reasoning

Integrating COTS Software into Systems through Instrumentation and Reasoning

Architecting Fault Tolerance with Exception Handling: Verification and Validation

Supporting crosscutting concern modelling in software architecture design

Contact Info

Product

Resources

About