Architectural Challenges for Agile Projects
The difficulty in working with Agile projects is their constantly changing
code. While UML tools try to provide architectural support, they are limited as their use requires a significant amount of time before the teams can see any
With changing code, developers often cannot afford to spend months updating diagrams. Out-of-date UML diagrams prevent developers from
enjoying its benefits.
Rapid code modifications in Agile projects prevent teams from benefitting from a well-defined architecture
and clear module boundaries resulting in a number of problems.
Undetected missing requirements
Without a commonly understood set of components for a project shared among
the team, developers are prevented from thoroughly examining architectural
issues. The lack of a well-defined structure for the project prevents
developers from noticing important missing capabilities during early
development. Discovery of such missing requirements towards the end of the
project requires significant time for both redesigning and implementing
the needed capabilities.
Lack of component reuse
Component reuse is widely known to be useful in reducing bugs, improving
productivity, and simplifying maintenance. However, the lack of a shared
diagrams, prevent developers from getting a complete view of the
architecture of the codebase, and limits the effectiveness of planning for
Difficulty using shared components
Even with components planned and designed for reuse, unclear module
boundaries result in developers not understanding the means for such usage.
Both module builders and users have no guidance as to the appropriate
dependencies and usage protocol - capabilities might be accidentally hidden
and/or important dependencies might not be available to those needing to use
Architectural erosion and code overlap
When multiple teams work on different parts of a code base and do not have
an updated view of module boundaries they find it hard to determine the correct
location for newly implemented features. Code often ends up in incorrect
locations, resulting in structural erosion and code overlap across different
Managing the challenges with Architexa
The Architexa suite has been designed to support developers in making architectural decisions and allow them to benefit from UML diagrams.
Understanding code architecture and preventing boundaries erosion
Diagrams built straight from the code allow developers to be connected
to the code, and high-level overview diagrams like Layered
Diagrams show developers major code modules for them to dive into.
Developers can easily determine where newly implemented features should be
placed and prevent architectural erosion.
Maintaining well-defined architecture and module boundaries
Architexa allows developers to easily get high-level
definitions of core code components, and examine the
logic flow of important use-cases. Developers can go into the code
step-by-step using the module dependencies, definitions, and capabilities, to
identify similar components and ensure that the architecture is kept up-to-date
with the code.
Having a consistent architecture shared with the entire team
Beyond support for discovering the architecture, Architexa allows
developers to share these architecture via diagrams with added notes
and comments. These diagrams act as a common reference point for a team and
allow for developers to access them when needed.