Structure101 Video Tutorials
Structure101 Studio lets you discover, create, and share your software architecture faster and easier than ever before. Whether you're a new or existing user, our video tutorials are here to help you get the most out of your Structure101 experience.
Setting the scene. The rationale, principles, and key concepts behind Structure101, in presentation format.
The structure of a codebase
How is your codebase organized now, why do you need organization, and what is a good organization anyway? (4:21)
Discover the properties that make a “well-structured containment model” so much simpler?. (4:56)
Creating well-structured containment
How you can create a “well-structured containment model” for your existing code-base. (6:14)
Levelized Structure Map (LSM)
With your objective firmly fixed in your mind, find out how to use the LSM to take your first step. Create a well-structured containment model using your existing source file dependencies and current physical organization. (Videos in this section refer to a previous product called "Restructure101", which is now the "Model" tab in Structure101 Studio).
Quick tour of the LSM
Understand the user interface that lets you manipulate the LSM into your ideal containment model. (2:51)
Understand how "levelization" makes the vast number of inter-dependencies in your code-base easier to understand. (5:59)
Understand grouping and slicing
Learn to use automatic grouping and slicing to expose structural patterns, reduce complexity, and make your code-base even easier to understand. (7:36)
Editing the LSM
Manipulate the LSM to construct your containment model and simulate structural changes to your code-base. (5:26)
Once you have a containment model you are happy with, it is time to put some constraints on container relationships, and share it with the team. Learn how to define, communicate and enforce layering and visibility rules across the whole team with Architecture Diagrams, IDE plugins, and build integration.
Sit in on a couple of conference talks presented by Chris. These include demos of using the LSM and Architecture Diagrams (towards the end of the talks in each case). There is a fair bit of overlap between these talks, but you might find it useful to hear the story presented from slightly different angles. (The talks refer to a product called "Restructure101" which was absorbed into Structure101 Studio as the "Model" tab).
You really should organise that codebase
From Oredev 2014. We can do without architecture early on, but at some point a clearly communicated architecture offers big productivity benefits to developers who otherwise drown in the expanding implementation-level detail. When you realize you are heading for a Big Ball of Mud, you have 3 choices – start over, suffer on, or knock your codebase into shape. This talk outlines principles, options and examples using Structure101 to get the best return for the cost and intellectual effort invested in a codebase. (42:37)
Where's your Architecture?
From 33rd Degree 2014. When a code-base grows beyond a certain size, any original arrangement of source files (or architecture) is often lost. The developers also become lost, and start drowning in the ever-expanding sea of classes. Usually the underlying code – the classes – are in reasonable shape. The problem is that there are too many classes to understand without any higher-level guiding structure, and physical structures (such as packages or jars) have become a tangled mess. The good news is that it is generally perfectly feasible to organize existing classes into a modular hierarchy with minimal impact on the implemented code. (64:10)
From JFall 2012. When the number of classes reaches some threshold, higher level abstractions are needed in order to manage the complexity of a growing codebase. This limit is usually overshot and the team is soon drowning in an ocean of classes. At this point it is time to restructure. (52:24)
From Oredev 2012. We can do without architecture early on, but at some point a clearly communicated architecture offers big productivity benefits to developers who otherwise drown in the expanding implementation-level detail. Do you start over, suffer on, or knock your codebase into shape. (52:42)
1 Our Structure101g Studio and Structure101g Build, "generic" versions, support third-party developed language parsers.
Currently, parser-specific help is available for:
Flavor Developer's Guide
- The Structure101g Flavor Developer's Guide
for creating your own language parser plugins, "flavors" or "backends" for Structure101g and ReStructure101g.
Independent resources on architecture management
We have gathered together a small and mostly random selection from the wealth of independent information available on the 'whys' and 'hows' of managing software architecture. We encourage you to browse at your leisure, and contact us if you are aware of further interesting and relevant materials.
Guidelines for Successful Acquisition and Management of Software Intensive Systems - A landmark study by The Software Technology Support Center and The Mitre Corporation concluding, among other things, that well-structured code is delivered in half the time, at half the cost and 8x less prone to defects.
Code Organization Guidelines for Large Code Bases - A presentation by the Spring Frameworks's Lead Architect, Juergen Hoeller, on why we must worry about code organization and be sure to manage our software architecture.
Stop Software Architecture Erosion - From QCon London 2011, a presentation by Bernie Merkle advising on preventing architectural degradation of a project by using tools for constant monitoring of the code, exemplifying with an analysis of Ant, Findbugs and Eclipse
Re-architecting a Large Codebase - A presentation by Sakonnet's Tim High from Dr Dobb's 2008 Architecture and Design World where Tim discusses how Sakonnet used Structure101 to refactor the architecture of over 2m lines of Java code.
No cycles allowed at package level, not even as a temporary measure! If it looks like we need a cycle, we force ourselves to look again and think harder.Juergen Hoeller, Architect, Spring Framework
Where did my architecture go - From QCon London 2011, a presentation by Eoin Woods on writing code that preserves the initial architectural design using conventions, dependency analysis, module systems, augmenting the code & checking rules, and language extensions.
Controlling your Architecture - From Jfokus 2009, Magnus Robertsson of Jayway shows how to control the code architecture manually, statically and dynamically in order to avoid an architectural drift leading to a big-ball-of-mud. For that, he recommends ways to enforce the reference architecture through peer review, code analysis, and zero tolerance to warnings and errors.
Tools exist for enforcing your architecture. Start today! No more "Word architectures"!Magnus Robertsson, Enterprise Architect, Jayway
Solid Principles of object-oriented design - Uncle Bob Martin's classic principles of good object-oriented design.
The Joy of Stats - Excerpt - If you have any doubt about, or want to convince someone of, the value of visualization just check out this amazing presentation.
Software Engineering Radio: Episode 115: Architecture Analysis - During Evolution of a software system, it becomes more and more difficult to understand the originally planned software architecture. Often an architectural degeneration happens because of various reasons during the development phases. In this session we will be looking how to avoid such architectural decay and degeneration and how continuous monitoring can improve the situation (and avoid architectural violations). In addition we will look at "refactoring in the large" and how refactoring can be simulated. A new family of "lint like tools for software architectures" is currently emerging in the marketplace I will show some examples and how they scale and support you in real world projects.
IEEE Paper: Structural Epochs in the Complexity of Software over Time A case study using a new complexity measurement framework called Structure 101 tracked the structural complexity of three open source software products through their different releases. The analysis found that, as these software products evolved, a large proportion of structural complexity in early releases at the application-code level progressively migrated to higher-level design and architectural elements in subsequent releases, or vice-versa.
Architectural Visualization Key to Code Reuse - From Gwyn Fisher, CTO at Klocwork, writing for Military Embedded Systems magazine - What can developers of military and avionics software systems do to take advantage of software reuse while ensuring that software is as bug-free and secure as possible?
Complexity kills. It sucks the life out of developers, it makes products difficult to plan, build and test ... Each of us should ... explore and embrace techniques to reduce complexity.Ray Ozzie, former CTO, Microsoft
Taming the complexity: The need for Program Understanding in Software Engineering - Detailed description from Prof. Raghu Sangwan of Penn State University, highlighting the need and the practice of program understanding and design-level refactoring using real world open source examples. One of the objectives of the program understanding course is to help professional software designers and developers become more effective in doing design and code reviews, and introduce software architects to techniques and strategies for architecture reconstruction and for monitoring systems for architectural conformance.
Stop the Software Architecture Erosion - Presentation by Bernie Merkle from ACCU 2009.
Domain-Driven Design Using Naked Objects - A book written by Dan Haywood on using the Naked Objects open source Java framework. The book includes a chapter on keeping the model maintainable using Structure101.
As systems become larger and more complicated, architecture assumes a more important role than has traditionally been the case. Exactly how organizations make use of architecture is an important indicator of their success in developing complex systems that meet their requirements in a cost efficient manner.
Software Engineering Institute, Carnegie Mellon University