Heading into 2023, Java architects, developers, managers, and CTOs are already shifting their focus for ways to do more with less, to increase efficiency, and to invest in working smarter. All the resolutions and positive vibes for 2023 are now mixing with potentially tough economic realities, layoffs, and budget roll-backs. Development teams have learned from the last few years that continuing to put off fixing technical debt is not an option. While business leaders are looking for ways to invest in more business resilience, development teams are having to re-focus on the resilience of their core applications that drive the business.

True resilience will require committing real resources and energy to application modernization, to stop taking shortcuts and to move beyond simple cloud migration if development teams want to drive real business change, future agility, and sustainability. Application modernization has moved to the forefront as a 2023 project imperative, so here’s some thoughts on what we can expect to see when it comes to major development trends in 2023:

Java Monoliths in the Cloud Start to Crack

2022 made it safe to wade into the monolithic application pool again and consider the role of monolithic application architectures. Hey, it’s not all about microservices. Monoliths can be a viable pattern for many situations and have been for a long time. BUT, this brings us to the many Gen-1 cloud companies or deployments that either launched as monoliths many years ago (back in those early cloud days) or lifted-and-shifted-and-stopped, meaning they migrated their monolith to the cloud and kinda forgot about it or celebrated for awhile (yay cloud!) and then lost focus. The bill for those in-the-cloud monoliths comes due in 2023 as they are showing their age and that long-delayed modernization or refactoring project can no longer be ignored.

Rise of Architect Assistance Tooling: AI-assisted Software Engineering

Software architects - especially Senior Java Architects - don’t have a lot of tools designed for their needs. Sure, there are a plethora of lower-level developer tools, IDEs, graphing, and profilers that most architects grew up on, but purpose-built tooling that truly helps an architect, well “architect,” really doesn’t exist - to do things like help identify architectural dependencies, recognize natural domain service clusters, define service boundaries and entry points, split services, build commons libraries, and recognize architectural drift. That’s where AI-assistance comes in, much like robot-assisted surgery, to help the expert do their actual job faster, smarter, with lower risk, more efficiently, and much more precisely.

Intelligent Refactoring Emerges Leveraging the Strangler Fig Pattern

Refactoring can be ugly and tough despite the best books, patterns, and training. And admit it, most developers would rather rewrite their older, legacy apps with a greenfield and no constraints. But the world is changing and Modernization Architects - or those architects that have been through a modernization process for real - understand that every successful modernization (perhaps an oxymoron) turns out to be part rewrite, part refactor, and part rearchitect as there’s almost always something to retain in the business logic that you’ll want to pull out and reuse, things you’ll want to upgrade and refactor as you move to microservices, and stuff that needs to be thrown out completely. Figuring all that out has gotten easier with the emergence of specific tools that help identify optimal entry points to service clusters, find and resolve complex dependencies, build common libraries, and then automate the Strangler Fig Pattern to roll out new microservices as you gradually manage the cutover from the monolith.

Iterative Modernization Replaces Big-Bang Rewrites

For large-scale modernization projects with high complexity, business leaders might be looking for the “easy button” but software architects know that the reality is much different. Carving out microservices from a monolith is an iterative process often requiring refactoring and replatforming. Unless your application is fairly simple, the “one-at-a-time” approach is the recommended path to ensure success and manage risk - and actually increase project velocity. Trying to do too much at once or attempt a “big-bang” modernization or re-write is why most app modernization projects fail, sputter, or just fizzle out. This is not necessarily as slow-and-steady as it seems, as iteration builds velocity that will outpace any massive undertaking in short order.

Technical Debt Payoff Comes Due

Over the last few years, application development and IT teams have gotten a little sloppy, relying too much on a ready-fire-aim methodology built on gut feel and growing budgets. As budgets tighten and higher scrutiny on projects becomes the norm, decisions must be made on where, and how to focus modernization spending based on data and analytics, rather than best guesses. Technical debt continues to spiral out of control bogging down innovation, so the need to accurately target what applications to modernize and how exactly to do that will move to the forefront.

Pragmatism Is Sexy in 2023

Managing risk makes a lot more sense in 2023 than it did over the last few years. Besides Covid learnings, the economic environment and tech job market are waking up development teams to balance results on the front-side with risk management on the back. Application modernization is a massive case in point here as application modernization projects have been failing at a rate of 79%. Developers and architects lacked the tools that helped them know where to start, how to accurately set expectations, and to understand the complexity, risk, and potential ROI - before the modernization project begins. By focusing on being data-driven - for example, measuring your technical debt and modernization ROI before you embark on a project - is a pragmatic way to reduce risk while accelerating and ensuring better results.

As we say hello to 2023 and goodbye to 2022, software architects, senior developers, managers, and CTOs will be looking at the year ahead through a new lens. Lessons learned and shortcuts taken over the last few years will converge and define what we all re-focus on in the new year - finding ways to better ourselves, reduce our debt, eat and live healthier, and trim that excess fat we’ve been ignoring. The same will go for our favorite enterprise applications where we need to improve our internal processes, exercise off our technical debt, focus on prevention through continuous modernization, and put those monoliths on that crash microservice diet we’ve been planning all year.