By Michael Seipp & Grant Smith 
Digital transformation has placed technology firmly at the heart of every business. As a result, software development has become a business-critical function. Ensuring the rapid development and ongoing quality of software is crucial for a company to survive and thrive.
Software development is now a mature business. Open source entered the mainstream in the 1990s, and Amazon cloud services date from 2006. The evolution of such tools and techniques has made it faster and cheaper for companies to undertake bold software projects, and the pace of change is not slowing down. Understanding these trends and what to do with them is a critical part of the future of technology leadership.
Here, we are going to look at four critical trends that will shape technology strategies in 2022, and provide insight into what they mean for the future of software development. Let’s get started.
Suggested reading: If you want to learn how to take a data-driven approach to development decisions, check out — How to Become a More Data-Driven Organisation.
Trend 1: Serverless computing
Serverless computing continues to make waves… again! And why should that surprise anyone, people have been discussing ways in which serverless is changing computing since Amazon launched its Lambda service back in 2014.
So, if it’s not really new, why is serverless on our list again? Well, it’s because businesses are finally starting to do it right. Serverless, like cloud computing more generally, has been widely adopted, but in relatively inefficient ways. The current trend is going back and doubling down on its strengths while backing away from its weaknesses.
How to do this trend right
First off, in case you didn’t know, serverless is a form of cloud computing, and it isn’t really “serverless”, it just involves outsourcing the management of those servers. If you need more information, check out our article on the Future of Serverless Computing.
Serverless enables developers to concentrate on writing code, not managing infrastructure. It gives developers more time to innovate and optimise their front-end, business logic and application functionality. This simplifies DevOps cycles because developers don’t have to describe the infrastructure needed to integrate, test, deliver and deploy code-builds into production.
Doing serverless right basically comes down to using it for the right reasons, and with the right applications. One of the great attractions of serverless is that you pay for execution only. The metre starts when a request is made and ends when execution finishes. For specific workloads, such as those requiring fast scaling, serverless is highly practical, faster and often more cost-effective than other forms of computing. However, the pay-as-you-use nature of serverless also means that the applications have to spin up every time they are used, which can cause latency issues for high-performance programmes, and cost problems for applications that make lots of information requests.
What you should avoid
While Amazon’s AWS Lambda, Microsoft’s Azure Functions, and Google’s Cloud Functions are leading the way, some smaller players have established a position in the market. Don’t choose a platform before you know what you are going to build. Each platform has evolved based on the offerings of the platform operator — so they are naturally better at some things than others. For example, if you use Google APIs and Google products, it makes sense to host with Google because the ecosystem should plug and play intuitively.
Fundamentally, you should only introduce an application to a serverless environment when it plays to its strengths. As we’ve addressed, always-on applications can run up costs, high-performance applications can struggle with latency, and monolithic applications won’t benefit from the modularity serverless offers.
How to get started
Work iteratively and avoid big bangs. Serverless is not the be-all and end-all. You don’t have to replace your whole estate with it. Choose the parts of your system which would benefit from being serverless and optimise other areas in other ways — be that in the cloud or not.
Lastly, commit to monitoring and measurement. Monitoring serverless workloads is more complicated than monitoring the presence of a process on a server. However, it’s usually more enlightening. You end up monitoring the actual functions being performed, not just whether a process is in memory.
Trend 2: Microservices
This trend is also old news and has resurfaced on our list because people are finally starting to do it right. Again, this has to do with leaning into the strengths of microservices, rather than attempting wholesale adoption where the use case is weak, or maybe misguided. This trend may actually see microservice adoption scale back where it doesn’t work. Long-term, however, we expect to see a growth in microservices as more of the underlying software architecture and development team structures become aligned with how microservices function.
How to do this trend right
Put simply, microservices are an application component that is tightly scoped, strongly encapsulated, loosely coupled, independently deployable and independently scalable. They allow teams to deliver a discrete piece of functionality without the need to engage with heavyweight change and test processes that can bog down a large monolith application.
Microservices work well when you have a good grasp of the roles of the different services required by your system. This approach avoids development delays, coding challenges, and service interdependencies and can meet rapid scaling requirements. For that reason, make sure the microservices you’re building need frequent changes or iterations, or it will be a waste of effort to build them in the first place.
What you should avoid
Microservices have to be independent to gain architectural benefits. Developers must adopt new patterns and abide by numerous architectural constraints to ensure that the microservices are independent. Taking a piecemeal approach to microservices is only practical if you are building new functionality or the piece of the monolith you’re replacing isn’t a mass of interdependencies.
As with serverless, it’s all too possible to improperly adopt microservices within the wrong context. Don’t try to build microservices on top of a monolithic database. Microservices need their own data store. Microservices can deliver tangible benefits, but success is often elusive due to companies not being thorough enough about why, when and how they should be used.
How to get started
Microservices can be implemented in a range of programming languages and might use various infrastructures. The most critical technology choices are the way microservices communicate with each other and the protocols used for the communication.
Success also depends on team structures being changed, distributed computing skills, and mature DevOps and agile practices. So, a potentially significant change management project might be needed before you can really get started.
Fundamentally, when building microservices, you should start with the data and work upwards through your application. Work out where the most significant points of contention are and work from there. Use the 80/20 principle — e.g. turning 20% of the application(s) into microservices will probably yield 80% of the benefit.
Trend 3: AI/ML and the impact of data science on decision making
Finally, we’re getting into truly new territory. AI/ML may have been talked about for a long time, but it’s only now that these capabilities are in reach for a wide range of businesses. Primarily, this is driven by on-demand and customisable AI-based software like Google’s TensorFlow, IBM’s Watson and Infosys’ Nia.
How to do this trend right
Fundamentally, this trend is about improving decision-making, planning and strategy, not necessarily about end-user capabilities. AI/ML algorithms can help developers find hidden value in under-utilised or non-utilised data, identify trends, and then make decisions to meet specific objectives. Typical examples include:
- Product strategy: In-depth analysis of how products are used today in order to identify the best ways to evolve.
- Process improvements: Better understanding how processes work today in order to improve project timelines, cost estimates and prioritisations.
- Automated testing and debugging: Applying pattern detection for in-depth analysis, identification, and categorisation of error types.
- Smart assistants: These tools actually assist with development, speeding up simple processes and improving quality control. A great example is Kite.
Fundamentally, the application of AI in software development encourages developers to become more agile in how code is written, tested, and delivered to production teams.
What you should avoid
Under-funding can prove terminal. Most businesses underestimate the cost of gathering and labelling data. They are then faced with difficulty getting meaningful results in a data deficient environment. You also need to beware of unintended consequences that arise from flawed models, such as algorithmic bias. It’s critical to be deliberate and specific in your planning, and give it time to iteratively work towards a conclusion.
How to get started
Ideally, you should start with a pilot project and gather results. This will help deal with the main pitfalls related to underfunding, elevated expectations and limited data. By staying focused on a specific project it’s easier to curate the right data, work on a small scale to prove value, and build up enough of the system so that you can evaluate its performance and begin iterating.
It’s also important to note that only a small part of real-world machine learning systems are made up of machine learning code. Make sure critical components such as data management, front-end product interfaces, and security are handled by your regular software.
Trend 4: Low-code/No-code
Low-code/no-code promises to expand application development out of development teams. While this is hailed by some as a solution to all custom software considerations, we believe the market is probably decades away from really delivering these outcomes. But that doesn’t mean this isn’t a trend to understand or embrace within a limited context.
How to do this trend right
First off, it’s important to note that this isn’t just one trend. There are low-code platforms like Appian and Boomi Flow. There are also orchestration mechanisms such as Zapier and IFTTT. Both are useful, but neither is really a replacement for skilled developers and technologists.
Look to implement low-code projects for small changes and simple automation. These can have an impact on workflows and enable non-developers to tweak how they engage with technology. Low-code application platforms (LCAPs) allow professional IT and business subject-matter experts to develop digital solutions rapidly. But this needs to be carried out in tandem with more sophisticated programs built using more traditional methods.
What you should avoid
Beware of the hype and don’t fall into the trap of thinking low-code/no-code can solve your development challenges. In fact, Gartner basically states that “no-code” doesn’t really exist and is just low-code rebranded by marketers.1
Fundamentally, don’t mistake “simpler” for “better”, and just because something is simple doesn’t mean you should adopt it, or that it will actually be simple to roll out for you. Especially if you already have engineers experienced with a more “complex” solution, you should likely continue to expand that expertise rather than try and switch to a less capable foundation.
Moreover, don’t overestimate the capability of low-code/no-code applications — they will probably disappoint you. Low-code/no-code cannot replace the flexibility, customisation, and functionality of standard programming. Don’t change your business to fit the tool just because it’s easy.
How to get started
You should think about low-code/no-code as part of a broader trend that is making programming more accessible. This ties in with increasingly simple programming languages like JavaScript and Python, along with other even more modern languages (e.g. Rust, Go, Kotlin) that use type inferences and null safety, etc.
However, again, just because something is simple doesn’t mean you should adopt it. Think about your specifics, the people you have today and your recruitment pipeline. Then, align that with your product development strategy.
Lastly, having visibility within the business over low-code/no-code projects is essential. By setting up a hub for these applications, you can ensure that business-generated low-code applications are documented, understood, maintained, and managed. Scalability is always an issue.
There are 101 Ways to use these trends, 101 Ways can help
We aren’t on the brink of a vast technological revolution, it’s a continuous process and has been happening for over 30 years. Any organisation using or delivering software must develop the right strategies to take advantage of constantly shifting trends in software development.
The opportunities are enormous, but with opportunities comes the need to marshal resources and manage risks. At 101 Ways, we can help you restructure your teams, develop the in-house leadership skills and expand your technical capabilities to meet these trends and challenges head-on. Get in touch if you want to learn what’s next.
