Create the Virtuous Cycle in your Applications
Building great applications is not just about technology, but the mindset you have. Plan, build, and deliver successful applications that continue to improve and increase in value over time.
Download the report
This report outlines the primary guidelines and patterns you need for building modern web applications, including when and where to apply technologies involved in the process.
Author Ron Northcutt helps software architects, developers, and IT leaders understand the underlying cycles at play, including how to evaluate solutions available today and in the future.
Once you know how to properly view problems, you’ll learn how to apply Headless, Hybrid, and Low Code in the context of the proper mindset.
The result is the ability to plan, build, and deliver successful applications that continue to improve and increase in value.
The core concepts in the report define the framework that helps you build better applications.
The term software crisis was coined at the first NATO Software Engineering Conference in 1968 in Germany when the attendees gathered to discuss the new concept of “software engineering” and were surprised to learn that similar issues were plaguing them all.
They used “software crisis” to describe the common problem.
When an application is trapped in the vicious circle, most attempts to extend or improve the project actually only exacerbate the underlying problems.
Everything done to advance or extend the application leads to greater problems like increasing technical debt, bugs, poor performance, and slower delivery times.
Eventually, the application must be decommissioned or replaced.
Component Based Design
The solution to the software crisis is component-based design.
Component-based design emphasizes the separation of concerns in terms of application functionality.
These components may be services, objects, functions, or other logical pieces in a system, but the concept remains the same.
With proper component-based design, we can create workflows that are optimized for more efficient development.
Applications can become faster, more performant, and less error-prone over time.
They’re also easier to maintain, and we naturally develop the ability to pay down technical debt or simply avoid it altogether.
The solution to the "software crisis" is component based design. Ideally, the components in a composable system should be:
- Modular: Good components can be added, removed, or swapped out with ease.
- Independent: Components should be as independent as possible.
- Stateless: Components should treat each request or interaction as an independent transaction, regardless of previous interactions.
- Reusable: If a component is modular, independent, and stateless, then it will also be reusable as well.
In a truly composable architecture, you can take any component out and replace it without impact on the rest of the system.
Creating the Virtuous Cycle
Separation of Concerns
This is a design principle that divides an application into distinct sections
Keep it Simple
The most resilient systems tend to be very simple, and so needless complexity should be avoided
Single Responsibility Principle
Every component in a modular system should focus on its own part of the whole.
Think of the User
This includes not only the end user experience (UX) for the application, but also the future developer experience (DX)
Don't Repeat Yourself
A general rule of thumb is that if you are building something more than once, then it needs to be standardized and reusable.
Suppress some of the complexity from the user and maintain a simpler interface that gives the user what they need.
Ensure that your software is flexible enough to work in a variety of situations.
Perfect is the Enemy of Good
Focus on creating the virtuous cycle and allow good results to become great results.
One of the fastest ways to build applications is by utilizing open source technology.
Comment Your Code
Documentation describes how the code is expected to work, how to use it, and often why certain choices were made
Adopt consistent standards across the project, including basic things like code formatting and commenting conventions.
Starting simply and focusing on the fundamentals ensures that the project can continue to grow and evolve over time