Cloud changes the way we develop and operate applications. Big monolithic applications require significant time to release new features. Legacy applications have tight connections with other systems pressure developers for deadlines when they want to deliver high quality software. The DevOps and cloud era enables a new way of working. It demands new application development techniques. Keywords here are: small, networked, and developer-oriented. To become faster and more agile, develop modern applications which these 3 principles in mind. In this article we will highlight the main concepts of these principles and explain why they are important.
What makes a modern application?
In organizations where application development plays a crucial role, probably everyone has a view on what modern applications are. Searching around on the internet as well as various discussions leads us to several aspects to keep in mind when talking about modern applications:
- Developers love to use state-of-the-art languages like Java, Go, Ruby, NodeJS and Python. Older programming languages like Progress, Cobol and so on are not considered modern. However, these languages are still needed for various (mission-critical) systems. Those should not be forgotten.
- Modern applications use APIs to communicate with each other and expose their services to end-users. Business logic is exposed through the APIs as well as through the GUI in a human friendly way.
- Every modern application requires a decent (infrastructure/tech) stack that supports the application in its best possible way. Think of cloud technology stacks that enable dynamic scaling, high availability, and loosely coupling.
- Often it is unknown what the client looks like for your application. Perhaps it’s a website that acts as a front end and built-in JavaScript. Or it is a mobile, native app. You don’t know how many clients are connecting to your application. Modern apps need to support an unknown number.
With these common characteristics listed, it’s time to align these with the development principles.
1. Keep it small
Every application needs to undergo a number of phases for every iteration. Design, develop, implement and maintain it. Every phase represents a small increment to build a new version of the application. Small applications over big chunks are key because of several reasons.
- A small scope of an increment means faster delivery. Build, test and deploy efforts reduce time to market. Faster feedback enhances new improvements to the next increment.
- Smaller code bases over large repositories make it easier for developers to understand. They have to analyze fewer code lines and can jump to the most relevant aspects faster. Less time is needed for anyone who touches the application to learn it. Business logic is easier to reveal. Decision-making is faster, also in refactor sessions.
- Testing is easier and faster since tests are executed faster. They are easier to understand for developers since there is less code. Better test scenarios (the non-happy flows) can be a positive result.
- Error handling and problem handling are done faster. Digging into the source code to find root causes is easier since you can pinpoint your efforts.
- Multiple teams can work on several applications at the same time. Consider a big monolith that has a bunch of lines of source code which requires multiple teams to understand and work on. Releases are slowed down due to multiple processes which depend on several people.
- Fewer vulnerabilities: a smaller code base, also that of third-party dependencies means fewer security issues to analyze and fix. Besides this, the attack surface is reduced.
And last but not least: smaller means less complex in more aspects. This applies to everything that has to do with the application. It’s about the business logic, DB schemes, architecture diagrams, processes, dependencies, connections, security issues etc.
2. Keep the network in mind
Networked applications become increasingly important. In the past, an application would run on a single system. If that system fails, the entire application was down. After this initial period in time, applications moved to a “three-tier” architecture: presentation layer, business logic, and the data layer. Derived from this, applications moved to micro-services. Every component has a dedicated purpose.
Speed and latency
Speed of an application and network latency are very important aspects for applications to work correctly. Running an application on a single system was the fastest option for a long time. Networks were considered slow and unpredictable. High latency was a real problem.
With cloud technology, this changes a lot. Networks are extremely fast, the number of hops between multiple services is limited. In addition to that, latency decreases.
Faster and more reliable networks mean: the application is more resilient. Network related problems are handled by the application: redirect traffic to another server, switch to another data-center (or even an entire region) or store messages in a queue to be handled later. Your application becomes more way more flexible.
Standards and protocols
Another benefit is the flexibility to connect to other (cloud) services. They all “speak the same language” since they all use HTTP (based) protocols. In the past, applications used proprietary protocols which were vendor-specific. This resulted in a vendor lock-in which was hard to get out. Besides this, you depended heavily on the tool vendor to create integrations and other aspects. Every Operating System has a browser that speaks the standard HTTP protocol. Under the surface, Curl is a tool that is heavily used in the application landscape. Both technologies speed up the ease of use for networked-based applications.
Applications that consist of small components are easier to deploy and manage. Every component can be tested, deployed, and maintained independently of the other. Monitoring is easier since features are separated and can be disguised independently. Separation of concerns helps to improve team autonomy, which in turn helps the organization move to a DevOps way of working. This is especially true for networked applications.
Focus on the developers
Developers are your most important asset. The time they spend on nondevelopment activities is (most probably) less valuable since they do not contribute directly to business value for the end-consumers. To make the life of a developer a happy one, think of the following aspects:
- The developer environment should enable the developer to create high-quality code as best as possible. Without a properly integrated development environment (IDE), things are slowed down, developers lose their patience, interest and move on to another company. Business domain knowledge is lost when a lot of people leave in a relatively short period in time.
- It’s vital to run an application in a matter of minutes. In an ideal world, developers clone a Git repository, read some lines in the Readme file, execute some simple scripts and run the application locally (in a container). Changes to the code result in live changes to the application so they get instant feedback. Containers here are critical to support every platform a developer might use (Linux, Windows, MacOS).
- DevOps tools can’t be missed when it comes to Continuous Integration / Continuous Delivery. As the principles of CI/CD become more common in every organization, developers do not want to create their own pipelines anymore. Instead, they demand standard pipelines which are fed with custom parameters or generated pipelines which are created in a jiffy. The more complex aspects of these processes should be handled by specialized teams.
- Although several infrastructure components are still needed to host / deploy an application (in the cloud), developers want to use IaC tools and (standard) templates. Hopefully, these standard templates generate compliant resources, so developers don’t have to worry about it.
Having these aspects in place helps to keep developers focused on their core duties: construct business logic for powerful applications.
Get your organization started
Modern application development principles require an organization that is ready to support it. Key aspects to get this off the ground:
- Management should give top priority and spread the word about it. Even in 2021, organizations need to start working in an Agile way. Let alone CI/CD and DevOps. View organization from the outside in, instead of inside out.
- Treat developers as true heroes. Don’t save money on poor development workstations. Not only developers can automate stuff. Also, product owners and/or high-level managers need to be able to do technical related activities if they want or need to. Every business representative is also a tech guy in an IT-driven organization. This way you also help to bridge the gap between the management and the developers.
- Give developers time to learn new (cloud) technology so they can adapt to the networked way of working and benefit from cloud capabilities that support their modernized applications.
- Share and advocate practical examples of modern applications. Share success stories and explain business benefits. This way you help business representatives make their business cases so they can also help to accelerate modern application development over old processes and technologies.
All of this helps you go faster. And that is what you need.
Wrap up
Modern development principles put the spotlight on the best possible way that developers think and work on business applications. Focus on small and easy-to-understand applications which can be developed, tested, and maintained in an easy fashion. Smaller code bases reduce the mental efforts to understand it and it helps to reduce bugs and error handling. Your developers need to be able to work in a smooth fashion to get most out of their capabilities. It’s critical to have your (upper) management aligned with these principles to speed up and support modern applications which deliver business value in the best possible way.
