Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Framework Objectives
Overall Framework Design
Overview
Discussion
Related Research
Conclusions and Future Work
References
All Topics
Economics
Industrial Organization

A Family of Software Architecture Implementation Frameworks

Profile image of Marija Mikic-rakicMarija Mikic-rakic

2002, Software Architecture

https://doi.org/10.1007/978-0-387-35607-5_14
visibility

…

description

10 pages

link

1 file

Abstract

Software architectures provide high-level abstractions for representing the structure, behavior, and key properties of software systems. Various architecture description languages, styles, tools, and technologies have emerged over the past decade. At the same time, there has been comparatively little focus on techniques and technologies for transforming architectural models into running systems. This often results in significant differences between conceptual and concrete architectures, rendering system evolution and maintenance difficult. Furthermore, it calls into question the ability of developers to consistently transfer the key architectural properties into system implementations. One solution to this problem is to employ architectural frameworks. Architectural frameworks provide support for implementing, deploying, executing, and evolving software architectures. This paper describes the design of and our experience with a family of architectural frameworks that support implementation of systems in a specific architectural style-C2. These frameworks have been implemented in different programming languages and used on different hardware platforms, including resource constrained (e.g., hand held) devices. The frameworks are lightweight and extensible, and allow application monitoring and analysis at run time. To date, the C2 frameworks have been used in the development of over 100 applications by several academic and industrial organizations. The paper discusses the issues we have encountered in implementing and using the frameworks, as well as the approaches adopted to resolve these issues.

Related papers

Trends in Software Architecture Designs: Evolution and Current State
Samuel Mbugua, Christopher Agwenyi

Trends in Software Architecture Designs: Evolution and Current State, 2025

Software architecture combines architectural style and quality attributes with the high-level structure of software system abstraction through composition and breakdown. In addition to meeting the system's primary functionality and performance needs, a software architectural design must also meet non-functional requirements including availability, scalability, portability, and dependability. The set of components, their relationships, how they interact, and how each component is deployed must all be described in a software architecture. There are numerous approaches to characterizing software architecture, including object-oriented modeling with UML (Unified Modeling Language), the Architecture View Model (4+1 view model), and ADL (Architecture Description Language). With an emphasis on microservices, serverless architecture, event-driven architecture, domain-driven design, cloud-native applications, zero trust security, and artificial intelligence integration, this paper reviews the latest developments in software architectural concepts, comparing their trends and contributions to modern computing. This paper reviews the evolution and current trends in software architecture designs from 2016 to 2024. It highlights key shifts, emerging paradigms, and factors influencing architectural decisions. The study is based on a systematic desktop review of existing literature, focusing on industry and academic contributions. Findings indicate a shift towards cloud-native architectures, microservices, event-driven models, and AI-enhanced frameworks. The paper synthesizes these trends and discusses their implications for future software development.

View PDFchevron_right
An implementation framework for Software Architectures based on the coordination paradigm
George A . Papadopoulos

Science of Computer Programming, 2006

Software Architectures have evolved considerably over the last decade and, partly also due to the significant progress made in component-based development, have become a major subfield of Software Engineering. The associated field of Architecture Description Languages (ADLs) has also evolved considerably, providing numerous approaches to the formal specification and representation of architectural designs. In this field, one of its most interesting (and rather recent) aspects has been the exploration of different ways to map architectural specifications down to executable representations. In this paper, we present a methodology for mapping the generic features of any typical ADL to executable code. The mapping process involves the use of ACME, a generic language for describing software architectures, and the coordination paradigm. More to the point, we show how the core concepts of ACME can be mapped to equivalent executable code written in the coordination language Manifold. The result is the generation of skeletal code which captures and implements the most important system implementation properties of the translated architectural design, thus significantly assisting the programmer in filling in the rest of the needed code.

View PDFchevron_right
Software architecture: perspectives on an emerging discipline
Martina Tina

1996

This book examine architectures for software systems as well as better ways to support software development. We attempt to bring together the useful abstractions of systems design and the notations and tools of the software developer, and look at patterns used for system ...

View PDFchevron_right
A Brief Survey of Software Architecture
Riddhi Jesalpura

Software of today is becoming larger and more complex. More powerful ways of structuring complexity are consequently required, whether it is about development methodologies, structural programming, naming conventions, configuration management, or, as is discussed in this report, software architecture. A software system's architecture can be described as the " blueprint " of a system at the highest level of abstraction, describing the main components and their most important interactions. We discuss in more detail how architectures can be described and the uses of such descriptions. Much research so far has also been dedicated to methods and case studies, to make the research of practical interest. This report describes how the quality of the software can be ensured to a certain degree through informal approaches – not least because an architectural description provides a common understanding around which different stakeholders can meet and discuss a system. Formal approaches are also emerging, and there are a number of formal languages for description of a system's software architecture. This report presents a brief survey of the field of Software Architecture; both informal and formal approaches are covered and discussed. The report concludes with presenting the author's planned research, aiming at answering how component-based architectures can be designed to handle change.

View PDFchevron_right
A report on the first european conference on software architecture (ECSA'2007)
Carlos E Cuesta

2009

Software Architecture, defined as the formal study of the structures and patterns of complex software systems, is already in its second decade as a regular discipline within Software Engineering. Not so long ago, architectures were simply left implicit. Today this would not be possible anymore; software applications cannot be conceived as isolated monoliths. Almost any software piece is now part of another system, and these systems have become themselves distributed, more complex, and larger.

View PDFchevron_right
The role of architecture frameworks : Lessons learned from ISO / IEC / IEEE 42010 ∗ ( extended abstract )
Rich Hilliard

This paper examines the central role of an architecture framework within the larger endeavour of the architecting of enteprises, systems-of-systems and complex systems. The paper presents lessons learned from the development and use of IEEE 1471:2000, Recommended Practice for Architectural Description of Software-intensive Systems and its successor, ISO/IEC/IEEE 42010:2011, Systems and software engineering — Architecture description. The lessons learned address areas including: modeling and notations, method and process definition, and tooling, with recommendations for the continued evolution of the NATO Architecture Framework. 1 Background IEEE 1471:2000, Recommended Practice for Architectural Description of Software-intensive Systems, was the first formal standard addressing the architecture of systems, where ''the term system encompasses individual applications , systems in the traditional sense, subsystems, systems of systems, product lines, product families, whole enter...

View PDFchevron_right
Software Architectures and Embedded Systems
Sam Malek, Marija Mikic-rakic

Software architecture has emerged as an area of intense research over the past decade [25,32]. A number of approaches have been proposed to deal with architectural description and analysis [21], architectural styles [8], domain-specific and application family architectures [4,35], architecture-based dynamic system adaptation [29], and so forth. By and large, however, these approaches share assumptions that make them suited specifically to the domain of traditional, desktop-based, possibly distributed development platforms. Those (comparatively few) architecture-based solu-tions that have focused on software systems for embedded devices (e. g., [28]) have had to face some of the same challenges (e. g., applying solutions across an application family), but also appear to have had some different priorities (e. g., ensuring efficient, architecture-compliant sys-tem implementations).

View PDFchevron_right
Definition and Documentation of Software Architectures
David Parnas

This paper discusses the work of the software architect by describing a software architect's concerns and the documents that a software architect should produce. It proposes a definition of software architecture and discusses archtectural design criteria based on the idea that every architecture is expected to meet a specified set of goals. We start with a discussion of the meaning of "architecture", then discuss the goals of an architect, proceed to what's needed to achieve those goals, describe ways of documenting architectural design decisions, and finally discuss how to determine how well the design goals have been met for any given architecture.

View PDFchevron_right
Object-Oriented Architectural Support for Developing Complex Systems
Giorgio Bruno

1999

Object-oriented software evolves over time, and it would be ideal if we could capture the persistent parts of the software early on and then derive the transient versions of the software from the persistent parts. Capturing the persistent parts of the software allows us to better maintain the integrity of the program during its evolution. This is the goal of software architecture. In this paper, we emphasize an approach called O3ML (Operational Object-Oriented Modeling Language) to model complex software systems using a sound software architecture which is centered on the creation of a system prototype with integrated design requirements and a simulation framework. This methodology supports the prototyping of complex computer-based systems by providing: (a) a multi-domain approach to capture the architectural complexity of real-world systems; and (b) a mechanism for the simulation of the conceptual, functional and implementation features of the design and the user requirements

View PDFchevron_right
A Survey on different Software Architectural Styles
Govind S

National Conference - AISE (Artificial Intelligence and Software Engineering)

This paper highlights the importance of Software architecture in the present IT industry scenario. It focuses on different architectural styles and their suitability in existing projects. The paper provides an overall view of the importance of Software Architecture in the present context.The intricacies involved in the design issues are also highlighted

View PDFchevron_right

References (35)

  1. A. Birrell, B. Nelson. Implementing Remote Procedure Calls. ACM Transactions on Computer Systems, 2(1):39-59, Febru- ary 1984.
  2. E.M. Dashofy, N. Medvidovic, R.N. Taylor, Using off-the- shelf middleware to implement connectors in distributed soft- ware architectures. In Proceedings of the 1999 International Conference on Software Engineering, Los Angeles, CA, pp 3- 12.
  3. F. DeRemer and H. H. Kron, Programming-in-the-Large ver- sus Programming-in-the-Small. IEEE Transactions on Soft- ware Engineering, June 1976.
  4. E. Di Nitto, D. S. Rosenblum. Exploiting ADLs to Specify Architectural Styles Induced by Middleware Infrastructures. 21 st International Conference on Software Engineering, Los Angeles, CA, May 1999.
  5. G. Fregonese, A. Zorer; G. Cortese. Architectural framework modeling in telecommunication domain. Proceedings of the 1999 International Conference on Software Engineering, Los Angeles CA 1999.
  6. A. Goldberg. Smalltalk-80: The Language, Addison-Wesley, 1989.
  7. M.M. Gorlick, R.R. Razouk, Using Weaves for Software Con- struction and Analysis. In Proceedings of International Con- ference on Software Engineering (ICSE '91), IEEE CS Press, Los Alamitos, Calif.,1991, pp. 23-34.
  8. I. F. Haddad. X/Motif Programming. Linux Journal. Issue 73 May 2000.
  9. R.E. Johnson. Documenting Frameworks as Patterns. In Pro- ceedings of the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA '92), Van- couver, BC, Canada, 1992.
  10. T. Lindholm, F. Yellin. The Java Virtual Machine Specifica- tion. 2nd Edition Java Series. Addison Wesley 1999.
  11. M. Maybee, D. Heimbigner, L.J. Osterweil. Multilanguage Interoperability in Distributed Systems: Experience Report. In Proceedings of the 18th International Conference on Software Engineering, Berlin, Germany, March 1996.
  12. N. Medvidovic, P. Oreizy, R.N. Taylor. Reuse of Off-the- Shelf Components in C2-Style Architectures. In Proceedings of the 1997 International Conference on Software Engineer- ing, 1997. pp 692 -700.
  13. N. Medvidovic, M. Rakic. Exploiting Software Architecture Implementation Infrastructure in Facilitating Component Mo- bility. In Proceedings of the Software Engineering and Mobil- ity Workshop, Toronto, Canada, May 2001.
  14. N. Medvidovic, D. S. Rosenblum, D. F. Redmiles, J. E. Rob- bins. Modeling Software Architectures in the Unified Model- ing Language. ACM Transactions on Software Engineering and Methodology. To appear, December 2001.
  15. N. Medvidovic, D. S. Rosenblum, R. N. Taylor. A Language and Environment for Architecture-Based Software Develop- ment and Evolution. In Proceedings of the 1999 International Conference on Software Engineering, pp.44-53, 1999.
  16. N. Medvidovic, R.N. Taylor. A classification and comparison framework for software architecture description languages. IEEE Transactions on Software Engineering, Jan. 2000, vol 26(1), p. 70-93.
  17. N.R. Mehta, N. Medvidovic, S. Phadke. Towards a Taxonomy of software connectors, 2000 International Conference on Software Engineering, 2000, Limerick, Ireland.
  18. R. Orfali, D. Harkey, J. Edwards. The Essential Distributed Objects Survival Guide. John Wiley & Sons, Inc. 1996.
  19. P. Oreizy, N. Medvidovic, R. N. Taylor. Architecture-Based Runtime Software Evolution. In Proceedings of the 20th In- ternational Conference on Software Engineering, pp.177-186, Kyoto, Japan, April 1998.
  20. D.E. Perry, A.L. Wolf. Foundations for the Study of Software Architectures. ACM SIGSOFT Software Engineering Notes, vol. 17, no. 4, pp. 40-52, October1992.
  21. J. Prosise. Programming Windows with MFC. Microsoft Press, 2nd Edition. 1999.
  22. J. Purtilo. The Polylith Software Bus. ACM Transactions on Programming Languages and Systems, January 1994.
  23. M. Rakic, N. Medvidovic. Increasing the Confidence in Off- the-Shelf Components: A Software Connector-Based Ap- proach. Proceedings of the 2001 Symposium on Software Re- usability, Toronto, Canada, May 2001.
  24. H.C. Rao. Distributed application framework for large-scale distributed systems, Proceedings the 13th International Con- ference on Distributed Computing Systems, 1993. pp 31 -38.
  25. S. P. Reiss. Connecting Tools Using Message Passing in the Field Environment. IEEE Software, 1990.
  26. J.E. Robbins, N. Medvidovic, D.F. Redmiles, D.S. Rosen- blum. Integrating Architecture Description Languages with a Standard Design Method. In 20th International Conference on Software Engineering, April 1998, pp. 209-218.
  27. B. Shannon, M. Hapner, V. Matena, et al. Java 2 Platform, Enterprise Edition: Platform and Component Specifications (The Java Series) by Addison Wesley 2000.
  28. M. Shaw et al. Abstractions for Software Architecture and Tools to Support Them. IEEE Transactions on Software Engi- neering. Vol. 21, no. 4, pp 314-335, April 1995.
  29. M. Shaw, D. Garlan. Software Architecture: Perspectives on an Emerging Discipline. Prentice-Hall, 1996.
  30. B. Spitznagel, D. Garlan. A Compositional Approach for Con- structing Connectors. Submitted to The Working IEEE/IFIP Conference on Software Architecture, The Netherlands, Au- gust 28-31, 2001.
  31. R.N. Taylor, et al. A Component-and Message-Based Archi- tectural Style for GUI Software. IEEE-TSE. 22(6), 1996.
  32. S. Williams, C. Kindel. The Component Object Model: Tech- nical Overview. Dr. Dobbs Journal, December 1994. http://msdn.microsoft.com/library/default.asp?URL=/library/te chart/msdn_comppr.htm.
  33. Sun Microsystems Inc. Remote Method Invocation. http://java.sun.com/docs/books/tutorial/rmi/index.html
  34. Case studies of IBM San Francisco usage (http://www- 4.ibm.com/software/ad/sanfrancisco/casestudies.html).
  35. A Discussion of the Object Management Architecture (OMA) Guide, OMG, 1997.

Related papers

Design and evolution of software architecture in practice
Elmer Sandvad

Proceedings Technology of Object-Oriented Languages and Systems. TOOLS 32, 1999

With special focus on software architectural issues, we report from the first two major phases of a software development project. Our experience suggests that explicit focus on software architecture in these phases was an important key to success. More specifically: Demands for stability, flexibility and proper work organisation in an initial prototyping phase of a project are facilitated by having an explicit architecture. However, the architecture should also allow for certain degrees of freedom for experimentation. Furthermore, in a following evolutionary development phase, architectural redesign is necessary and should be firmly based on experience gained from working within the prototype architecture. Finally, to get it right, the architecture needs to be prototyped, or iterated upon, throughout evolutionary development cycles. In this architectural prototyping process, we address the difficult issue of identifying and evolving functional components in the architecture and point to an architectural strategya set of architectures, their context and evolution -that was helpful in this respect.

View PDFchevron_right
Reflection on Software Architecture Practices - What Works, What Remains to Be Seen, and What Are the Gaps
Chung-horng Lung

5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05), 2000

This report presents a reflection on software architecture practices based on our past ten year's industrial experiences, particularly in the areas of communications networks and telecommunications and. The report summarizes the methods, tools, and techniques that we have used on various projects. We also discuss, based on our experiences, what methods are useful, what remains to be validated, and what the gaps are between the state of practices and our desired wishes.

View PDFchevron_right
Connecting Architecture and Implementation
Rainer Weinreich

Lecture Notes in Computer Science, 2009

Software architectures are still typically defined and described independently from implementation. To avoid architectural erosion and drift, architectural representation needs to be continuously updated and synchronized with system implementation. Existing approaches for architecture representation like informal architecture documentation, UML diagrams, and Architecture Description Languages (ADLs) provide only limited support for connecting architecture descriptions and implementations. Architecture management tools like Lattix, SonarJ, and Sotoarc and UML-tools tackle this problem by extracting architecture information directly from code. This approach works for low-level architectural abstractions like classes and interfaces in object-oriented systems but fails to support architectural abstractions not found in programming languages. In this paper we present an approach for linking and continuously synchronizing a formalized architecture representation to an implementation. The approach is a synthesis of functionality provided by code-centric architecture management and UML tools and higher-level architecture analysis approaches like ADLs.

View PDFchevron_right
A language and environment for architecture-based software development and evolution
David Rosenblum

Proceedings of the 21st international conference on Software engineering - ICSE '99, 1999

Software architectures have the potential to substantially improve the development and evolution of large, complex, multilingual , multi-platform, long-running systems. However, in order to achieve this potential, specific techniques for architecture-based modeling, analysis, and evolution must be provided. Furthermore, one cannot fully benefit from such techniques unless support for mapping an architecture to an implementation also exists. This paper motivates and presents one such approach, which is an outgrowth of our experience with systems developed and evolved according to the C2 architectural style. We describe an architecture description language (ADL) specifically designed to support architecturebased evolution and discuss the kinds of evolution the language supports. We then describe a component-based environment that enables modeling, analysis, and evolution of architectures expressed in the ADL, as well as mapping of architectural models to an implementation infrastructure. The architecture of the environment itself can be evolved easily to support multiple ADLs, kinds of analyses, architectural styles, and implementation platforms. Our approach is fully reflexive: the environment can be used to describe, analyze, evolve, and (partially) implement itself, using the very ADL it supports. An existing architecture is used throughout the paper to provide illustrations and examples.

View PDFchevron_right
The Past, Present, and Future for Software Architecture
Henk Obbink

IEEE Software, 2006

his special issue celebrates 10 years of software architecture conferences and workshops and the 10th anniversary of the first IEEE Software special issue on the topic in November 1995. We aim to address the latest thinking about creating, capturing, and

View PDFchevron_right

Related topics

  • Industrial Organization
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved