Post originally featured on VMblog.
There’s no doubt that 2024 will usher in an exciting era of new Generative AI solutions across a range of business and personal use cases. Under that noise, there are some serious issues across IT and software engineering organizations that need serious attention and are on the brink of big changes in 2024. Here are five 2024 predictions to track and keep an eye on.
Software Architects Get Some Long Needed AI-Love
Getting software architecture right is hard. Keeping your software architecture right over time is even harder. And modernizing an architecture you inherited from previous architects is nearly impossible. The good news for software teams is that generative AI holds a tremendous amount of potential to reduce the drudgery of everyday software development and maintenance. In particular, the dreaded task of framework and language upgrades and migrations can be greatly simplified with the latest round of AI-assisted developer tooling.
But unfortunately, software architecture – and the inevitable architectural technical debt that comes with it – needs something more than an AI-assistant magic button (sorry to say). In 2024 though, help is on the way in the form of AI-Augmented tools that focus on software architecture. This requires the ability to identify domains, peel away dependencies, and help architects extract clean services with well-defined boundaries and APIs. The focus is to support the expert, who in this case is the software architect, and give them the iterative tooling to rearchitect, refactor, or rewrite given their understanding of value streams and business processes.
Developer Productivity Turns a Corner, Finally
The state of developer productivity makes me sad. With all the investments and advancements in automation, shifting left, full stack development, the plethora of plug-n-play cloud services and XaaS options, the latest and greatest generative AI tools, and so on – developer productivity continues to plummet year after year. Perhaps we finally reached the cognitive load limits of developers and teams.
Having spent a considerable amount of time with organizations understanding and evaluating how they manage technical debt, I’ve come to the conclusion that until teams start proactively managing technical debt – not just simple source code tech debt but deeper architectural technical debt – then we’ll never turn the corner on improving developer productivity. That’s because technical debt is actually the root of the problem – while these other solutions have been merely chasing symptoms. In 2024, architectural observability and analysis solutions will provide a lifeline for teams that want to reverse their developer productivity woes. Reducing architectural technical debt will be the secret to unlocking developer productivity in 2024.
Governance Turns Its Focus on Software Architecture
Software governance, audit, and compliance tools have come a long way. Maybe not long enough yet, but automated governance and governance-as-a-service solutions are viable options for organizations today. Automated analytics can measure source code quality, check for security issues, detect composition problems, SBOM analysis, and more. Plug these into your CI/CD pipeline and compliance automation is looking pretty sweet.
But wait, what about software architecture and architectural compliance and governance? Architectural technical debt has a much greater effect on business velocity, cost efficiency, and productivity than any of this existing compliance and policy telemetry. To manage architectural drift, organizations in 2024 will start to turn to architectural governance tools that measure technical debt in the same cycles that they are tracking security, composition, and source code quality. Plug-in architectural observability baselining and drift detection directly in line with development pipelines, and teams will truly automate architectural policy and enact technical debt standards.
Look! Platform Engineering for Architects
Platform engineering is a pretty cool concept. The idea of building and managing self-service internal developer platforms (IDPs) for software delivery and life cycle management has kept SRE and DevOps teams busy in 2023. In 2024, software engineering leaders will leverage this experience and extend the concept to address their modernization backlog. The modernization experience for architects and developers is terrible: it’s complex, tedious, risky, and slow.
Enterprise architects looking to extend a broader and more consistent modernization approach across their architect teams will deploy modernization platform engineering to set enterprise-wide technical debt measurement and management standards. In 2024, enterprise architects will gain organizational visibility, tracking, and governance while line-of-business software architects will leverage reusable architectural observability tools and self-service capabilities to improve their modernization experience and productivity. A win, win for sure.
Observability Makes Inroads Into Software Architecture
Observability, AIOps, and OpenTelemetry are on a roll. They have truly made massive progress over the last three years, so why stop in 2024? While Application Performance Management (APM) tools have tried to scratch the surface of application modernization, they’ve mostly applied old monitoring and correlation technologies to technical debt and app modernization use cases. When all you have is a hammer then everything looks like a nail. Architects have tried to use APM and existing observability tools to solve their problems, but mostly because their DevOps teams have already paid for them. They need new tools and hardware (really software), not hammers and nails.
Summary
In 2024, enterprise and software architects will seek out observability solutions that are specifically designed for their app modernization, technical debt management, and architectural analysis needs. Architectural observability solutions will emerge that look deeply into software architecture to unearth domains, tease out dependencies, and surgically extract new services, microservices, and serverless functions. Think of these as new tools for the software architect’s toolbox. Instead of borrowing tools from their DevOps neighbors, in 2024 architects will use purpose-built solutions designed especially for their needs. And finally, they can return their borrowed but unused tools to their friends down the street.
