InfoQ: The Elusive Dependency
Architecture models how the system and its elements hang together. Yet the true complexity of architectural dependencies can be highly elusive. We share architectural information when we build integrated systems creating complex and hard to find dependencies. This article introduces a simple modelling approach to analyse of architectural dependencies within complex technology environments.
LogiGEAR Magazine: More just isn’t more
Most have probably heard the expression ‘less is more‘, or know of the ‘keep it simple and stupid‘ principle. These are general and well-accepted principles for design and architecture in general, and something that any software architect should aspire to. Similarly, Richard P. Gabriel (a major figure in the world of Lisp programming language, accomplished poet, and currently an IBM Distinguished Engineer) coined the phrase ‘Worse Is Better‘, in formulating a software concept that Christopher Alexander (a ‘real’ architect famous within software engineering) might have termed ‘piecemeal growth’ – e.g., start small and add later. But what happens if we continue to add more, even if they are just small, simple pieces? Read more…
Peer-reviewed academic publications at international conferences
Visualising Architectural Dependencies
Abstract: Visibility of technical debt is critical. A lack thereof can lead to significant problems without adequate visibility as part of the system level decision-making processes. Current approaches for analysing and monitoring architecture related debt are based on dependency analysis to detect code level violations of the software architecture. However, heterogeneous environments with several systems constructed using COTS, and/or several programming languages may not offer sufficient code visibility. Other limiting factors include legal contracts, Intellectual Property Rights or just very large systems. Secondly, the complexity of a software dependency is often greater than simple structural dependencies; including multi-dimensional properties, behavioural dependencies; and ‘implicit’ dependencies (i.e., dependency inter-relatedness). This paper proposes a simple modelling approach for visualising dependency relationships as an extension of the current approaches; while supporting complex dependencies. The model can be build using existing dependency analysis and general architectural knowledge; thus better suited for heterogeneous environments. We demonstrate the proposed modelling using an exemplar, and two field case studies.
Keywords: technical debt, software architecture, architectural dependency analysis
Towards an Architectural Viewpoint for Systems of Software Intensive Systems
Abstract: An important part of architectural knowledge is the capture of the environment and external system relationships through contextual viewpoints. However, the semantic definitions of software relationships do not adequately capture inter-system level relationships, and offers no guidance on implicit or indirect relationships. Yet the architect is tasked with the very responsibility of defining external relationships leaving him/her either unaware of critical relationships or, to ’roll their own’ based on aggregations of code-level call/use structures. This leads to critical gaps in the architectural documentation and communication problems within Systems of Software intensive Systems (S3) environments – if undetected can cause serious problems for development projects. S3 environments may also restrict the sharing of architectural knowledge due to either legal or contractual constraints, or contain an overwhelming amount of documentation due to size and number of involved systems – either scenario further adds to the challenge of identifying and describing the relationships. This paper presents a novel and light-weight S3 Architectural Viewpoint consisting of 1) an extensible taxonomy of system level relationships, 2) with a systematic, repeatable technique to detect both immediate and linked system level relationships. The goal is an architectural approach for the sharing and analysis of architectural knowledge relating to software system relationships in an S3 or ecosystem environment. The research is on-going and developed through the mining of existing software ecosystems and industry S3 architectures. Validation will be performed through case studies from industry collaborations.
Keywords: Software Architecture, Systems of Systems, Architectural Views
Publication: Click here to download
Conference: ICSE 2010
Conference Event: 5th Workshop on SHAring and Reusing architectural Knowledge (SHARK)
Software Architecture for Systems of Software Intensive Systems (S3): The Concepts and Detection of Inter-System Relationships
Abstract: Key to software architecture is the description of relationships between software components supported by commonly understood semantic definitions. However, the definitions do not adequately capture the inter-system level software relationships. This leaves software architects either unaware of critical relationships or, to ’roll their own’ based on aggregations of code-level call/use structures. This leads to critical gaps in the architectural description and communication problems within distributed development environments – as poorly understood relationships can inadvertently propagate changes and break system interoperability. The solution requires a description of new system level relationships and a new systematic, repeatable technique to detect both immediate and linked system level relationships. The solution will be developed through the mining of existing software ecosystems and industry systems of software intensive systems (S3) architectures. Validation will be performed through case studies from industry collaborations.
Keywords: Software Architecture, Software Relationships, Systems-of-Systems