Introducing Circle-Driven Development
Circle-Driven Development (CDD) is a revolutionary new software development technique that is lightweight and optimizes the output of developers. By using CDD, any team will give its engineers the power to work in isolation and complete large amounts of work independently. The core concepts of CDD have actually been around for a long time and most developers have already encountered it to some degree in their careers.
The Process
Its straightforward: do something, then do something else, then revert back to whatever was done in the first place.
This way, developers are always busy working on something and can continually evaluate different options. The philosophical backbone of circle-driven development is that it optimizes output over outcomes, which differs from other approaches to software development. The CDD process is extremely simple and can be learned in mere minutes: starting a circle isn’t a formal procedure and doesn’t need to be planned. Its important to note that there is no limit to circling; it can potentially go on forever. The more a programmer goes in circles the faster the process becomes, which is what leads to the high volume of output. Although there are typically only two steps in a circle, there can be any number.
Reasons For Circling
What tends to start a circle is that a team becomes dissatisfied with an existing solution or technology so they switch to another one because it solves some specific problems the original one had. Later, the team realizes that the replacement solution introduces new problems, so they are forced to revert.
For example, let’s say a team is tired of using a relational SQL database because they are constantly making changes to the schema. They switch to a modern NoSQL database that doesn’t have a schema and it solves this problem for them. However, they later realize that the lack of standardization of the newer NoSQL database is a real pain, since they need to learn a new query language and many tools don’t integrate nicely with it. So they end up circling back to the original SQL database and the circle is now complete.
Isn’t this like Agile?
This is a common misconception. Agile is about iteration, which implies progress, while CDD is about constantly circling between solutions. Agile is more about cycles rather than circles. The beauty of circle-driven development is its minimalism: the CDD model completely ignores customers, project managers, and all stakeholders. Instead, CDD is focused exclusively on developers. Customer feedback isn’t needed in CDD, since its all about programmer output. In the CDD world, the business side of the company doesn’t need to work with developers or even know about their process; notice how stakeholders are not mentioned at all in the above example about databases. This actually makes CDD simpler and faster to adopt than Agile.
Examples
There are many examples of CDD in the software industry:
- Early web applications used Java applets, which were feature-rich and did a lot of work on the client side. Later, most web apps started doing more work on the server side and making the client side dumb. In the past few years, web apps are client side-heavy again with JavaScript replacing applets. Server-side rendering is possible in Angular and React, so another circle may be approaching.
- SOAP is a highly structured method of communicating between web services which was introduced in 1998. The simpler and less formal REST architectural pattern became industry standard somewhat later. Today, the structured approach of GraphQL, which includes a schema and types, is gaining some traction.
- Waterfall development used to be standard in the software industry. Years later, many companies adopted Agile instead. Now we’re seeing waterfall make a comeback with processes like SAFe and disciplined agile delivery.
- Every developer has reverted their code changes using a version control system, which is actually a small example of CDD called a microcircle. This is related to the
test && commit || revert(TCR) workflow, which seems like CDD on the surface, but ultimately differs since a developer eventually makes progress with TCR.
Happy Circling!
Circle-Driven Development is a beautifully simple software development process which will accelerate any team’s productivity. By focusing solely on developers, CDD makes sure they are constantly busy and experimenting with different approaches and technologies. Feel free to share your CDD success stories and other examples in the comments!
