The technology industry went through a colossal leap in development over the last several decades. Virtually every tech field today, from web solutions and software to enterprise networks and hardware, has evolved tremendously since the late 1980s—which is commonly viewed as a reference point to the modern rise of the Digital Revolution—to be able to provide users with unprecedented choices in features and technical capabilities, enabled by continuously increasingly computing power of devices in our IT infrastructure and wide implementation of new technologies.
The growth has been so rapid, with major new trends and tech solutions replacing each other every couple years or so, it almost seems like the majority of people in the tech industry, whose job it is to bring all these transformations to life, never had time to slow down, take a break, and ask themselves where this path leads them.
Amid the abundant flow of highly enthusiastic reports in the media, praising the power of new tech such as AI or cloud computing and picturing the benefits of digital transformation, it can be really difficult to recognize problematic tendencies, increasingly manifesting themselves across all the fields of computer system development.
Are Excessive Complexity And Tech Stack Bloat Pulling Us Down?
There are a handful of trends and processes going on in modern-day, web, mobile, and enterprise software development that are all contributing to what can only be described as a crisis of development productivity, caused by an uncontrollable bloat that continues to flourish today.
And you don’t need to dig deeply into the backstage of software development to support this claim as evidence can be found everywhere.
Here are several of the most prominent examples.
- Despite hardware continuously gaining computation power, software is working with the same speed or even slower.
As both consumer devices and enterprise hardware solutions are getting more and more powerful every year, we are hardly able to see corresponding boosts in speed and general performance. Unfortunately, additional resources of new-generation devices are largely being wasted on satisfying new software’s growing appetites for computing power—all due to poor choices of engineering tools and general tendencies for prioritizing inelegant software development tools.
- Despite ever-faster Internet connection speeds, web pages are loading slower
A very similar picture can be seen in web development. Despite the internet connection speed growing more than 20 times over the last ten years alone, many websites are actually working slower than before. This is because web pages are getting bigger in size every year. Today the average web page is more than 3 megabytes in size, while in 2011 it was just 929 kilobytes. A 2019 study (https://backlinko.com/page-speed-stats) by Backlinko, based on the analysis of over five million desktop and mobile web pages, found that an average desktop page was taking 10.3 seconds to load and mobile pages needed a whopping 27.3 seconds to load on average. Extensive usage of JavaScript elements and library integrations that are so ubiquitous in web development of today are major contributors to this issue. This same software bloat has crept into desktop software through an adoption of Electron framework-based applications that utilize web technologies, which are slow and consume huge amounts of memory.
- Software solution providers are struggling to keep up with cross-platform delivery
As if the need to deliver increasingly complex and feature-rich products weren’t enough, software developers are also pressed to provide versions of their products for a growing number of platforms, both desktop and mobile. Building and updating the same application multiple times with different toolchains to support major platforms—with Windows, macOS, Linux, Android, and iOS as the main ones—is costly, complex, and brittle.
- The need to supply a constant stream of timely updates drains development resources
Shortening development release cycles and the need to supply various kinds of security, design, and functionality updates in a timely manner are other reasons it gets harder for developers to keep up with this bloat.
Being pressed by all these and other related factors doesn’t go without consequences: it forces developers to adopt the quickest and easiest solutions, sacrificing quality and code optimization because doing so seems to become the new normal.
Developer Pain Points across Programming Stacks: From COBOL to Java and Python
As mentioned above, some of the biggest issues that are burdening modern-day software development and jeopardizing productivity across fields are bloated and inefficient frameworks and development tools. Let’s take a closer look at several widely popular technology stacks to identify what the developers specializing in these tools are complaining about and concerned with the most.
COBOL
Despite being labeled as a legacy language since about the same time as the Digital Revolution started to unfold on a massive scale (late 1980s), COBOL development is still very much alive, mostly because numerous companies are still relying on the COBOL codebase and solutions that are written in this language and powering some of the most fundamental parts of their IT infrastructure.
As time goes by, however, COBOL legacy code gets more difficult and expensive to support, forcing enterprises to address the need for modernization.
Here are several direct quotes from the developers discussing the current state of affairs in this field.
"My mother spent much of her career as a COBOL programmer, dating back to the early 80s. She retired in 2015 and quickly got bored. I talked her into accepting part-time contract work, something to keep her busy. She got flooded by recruiters. They all told her the same story: ‘Big Corp’ is nervous because a critical system runs COBOL and the staff that used to support it have all either retired or died. She got the impression that most of the managers at ‘Big Corp’ had little to no regard for these ‘critical’ systems; they were just looking to save their own jobs, either by way of a miracle worker (wave a magic wand and fix 40 years of tech debt in 3 months) or a fall guy (it's the contractor's fault, not mine)," a user named jimt1234 said.
"Debugging 20-year-old Java code sucks, but a 40-year-old COBOL project, with source code backed up to 5-inch floppy disks—forget about it. I once met someone who migrated a COBOL project to Java. The biggest complaint wasn't even the language itself, but extracting business logic from a 40-year old spaghetti codebase. Sometimes bugs were part of the business logic itself and other developers who consumed the monstrosity had to make corrections on their side," a user named notimrelakatos said.
Java
The Java development ecosystem is a typical example of a technology stack getting excessively complex as new versions of the development tools are being released. Many Java developers are complaining about the differences in Java versions from 8 to 17 (the latest one currently) and the abundance of related compatibility and performance issues affecting their work.
Here are several noteworthy direct quotes.
"One of the reasons we're still on JRE8 is that any of the newer JREs that I tested throw crash panics on several tasks, and the ones that don’t take 40 or 50 hours to finish instead of four or five. That left me with the impression that stability and performance had been abandoned over throwing everything including the kitchen sink at it to try and attract people who like Rust and Go. Could be wrong, but the hand waving away the implication that 17 is slower than 15 at the end and not even trying to compare with 8, which is rock solid and crazy performant, leaves me thinking nothing actually changed," a user named DarkmSparks commented.
"In the move to Java 9 they broke Java's customary backward compatibility and left behind a lot of users. It doesn’t help that there is no good, clear and complete guide on how to upgrade SOAP clients. I went through this recently and learned that because Jakarta uses multi-release jars, we have to do the regular dependency changes and also change our fat-jar based build/release to Docker images. In other words, they decided to throw out decades of users’ investment in learning the ecosystem. I’m not surprised that people seem to be leaving the ecosystem," pabl0rg added.
JavaScript
JavaScript is without a doubt one of the main drivers of web pages’ gaining extra weight in recent years. This language offers web developers many powerful capabilities, such as getting real-time data from third-party sources or utilizing innovative technologies at low cost, but it’s not like they come without a price. An overload of JavaScript elements is the major reason for slow page-loading time and latency, especially when JavaScript elements are poorly written and/or integrated, conflicting with other components and resulting in compatibility issues.
JavaScript developers, understandably, tend to be unhappy about the growing complexity of web development and overall increasing "inelegance" of developing solutions in this technology stack with the emphasis on external frameworks and libraries that keep replacing each other.
Here’s a well-articulated comment by a JavaScript developer writing about the pain points of modern-day JS development:
"This is patently obvious to anyone who builds large web applications. Ten years ago we had ASWing, JSwing and plenty of other actual frameworks where you didn't have to diddle around with tons of logic embedded in templates which were embedded in other logic. But thanks to Apple, we're still saddled with this wretched Javascript/HTML paradigm that was never meant to do much more than inline some animated GIFs back in the 90s. Yes, it's gotten better (I've been doing this since the 90s, so I know). But it's so inelegant. To some degree this is just a problem with open web standards. It would be better if any one company actually had dominated to the point where they could write a closed standard, because at least it would be coherent and cross-platform. It was a lot easier to write a web app in 2010 than it is now, and it pains me to think how many hours I could have avoided reinventing the wheel if Flash had been allowed to stick around. Any app written entirely now on Canvas is just replicating a VM that already existed a decade ago in what was by then a much more mature ecosystem—and was faster than Canvas or WebGL is now."
Python
Similar to the Java development community members, Python developers today are forced to deal with multiple difficulties related to the transition from Python 2—which was released in 2000 and is now considered a legacy—to Python 3, facing compatibility issues and the need to migrate outdated Python code to the new platform.
"I think the situation is mishandled for this reason. Python 3 is basically another language, similar to Python 2. Calling it Python 3 is an exercise in marketing: instead of creating a new language to compete with Python 2 (along with all similar languages e.g. Julia) the existing Python 2 community was leveraged/shamed into supporting the new thing, and most importantly, Python 2 was killed by its maintainers (rather than handed off) so it couldn't compete with Python 3, and so that users would be forced to move somewhere else, Python 3 being the easiest. If it had properly been a new language, they could have taken more liberties to fix issues, like a single official package manager. And migration to Python 3 would have been more by consent, than by force," a user named Chris2048 points out.
Electron
Applications made using Electron, a popular framework that allows developers to create native apps with web technologies to deploy on multiple platforms at once, are a major contributor to worsening performance and growing latency of modern-day web solutions overall. Electron has been steadily gaining adoption in the industry since its release in 2013. A number of highly popular apps are built with this framework, including Slack, Skype, Visual Studio Code, WordPress Desktop, WhatsApp Desktop, Atom, etc. The main problem with Electron-made apps is that they are incredibly memory-intensive, consuming enormous amounts of RAM when active. This is due to the fact that every Electron app is in fact a browser in a separate window with Node.js server powering the backend.
Naturally, software developers are well aware of the problematic nature of Electron and all the downsides of using this solution.
"I am not sure what the point is of Electron: a resource-hungry app that literally is a wrapped web app. Instead of writing platform specific apps that leverage the power and capabilities of those platforms, we get a jack of all trades and master of none. Electron is a business decision, not an enlightened technical one. What value does Electron add to the user? I would argue none. The fact that Slack can’t find the resources to write actual Swift for a Mac App is just amazing to me. Instead we are essentially interacting with a lowest-common-denominator web app. Is a chat app that hard to write natively?" a user named briandear wonders.
"People built web apps 15 years ago in the dumpster fire that was web standards at the time. Browsers, even the good ones, didn't update themselves automatically. Most of the world was still on IE, which was actively hostile to web standards for the sake of lock-in. There was nothing like Babel to smooth over the rough edges, there were no polyfills. And even the standards that existed, when you got the opportunity to use them, mostly sucked. I think, given all that, we can deal with supporting recent-ish Chromium and the latest Safari, if it means bolstering web diversity and saving an order of magnitude in RAM and storage," a user named brundolf said.
Many web developers also point out that Electron codebase is considerably outdated by today’s standards: "It launched eight years ago; the web has changed a lot since then. Edge wasn't even around until 2015, much less being used for webviews."
Developer Productivity is in a Downward Spiral; This Has to be Reversed
The main point of reviewing the pain points of developers across the most common technical stacks is to demonstrate that modern-day software development is indeed going through a challenging time: a productivity drain crisis.
And it has to be addressed and resolved to allow us to move forward. As cliché as it may sound, there's always an opportunity with crisis. In our case, the opportunity lies in approaching the development process with the right mindset and selecting software development tools that are designed to solve this problem, leading the way to a new era of developer productivity. Embarcadero’s RAD Studio, a rapid application development package centered on a "write once, compile everywhere" approach, is such a tool. And adopting it can be a way to supercharge developer productivity and get relief from these pains.
What Does Productivity Mean in Software Development?
But first, we need to clarify what productivity actually is. In software development, we view productivity as the sum of developer productivity, business functionality, application flexibility, and product performance.
In order for the productivity crisis to be resolved, going through some mental transformations as an industry may be just as important as selecting the right tools. Specifically, companies need to adopt a healthier approach to budgeting the development and maintenance of software systems.
When estimating the costs of software projects, it’s important to budget for and recognize the importance of not just the cost of developers’ work, but also the tools used to build and maintain the software. Adopting open-source development tools that are free but time consuming can lead to huge long-term expenses due to developer productivity losses.
Unfortunately, many companies today seem to be extremely shortsighted and careless when it comes to long-term planning of development costs and thinking strategically. Future maintenance, ease of testing, and the ability of an application to fulfill its purpose are all hidden productivity costs. Turning a blind eye to them is one reason that all-encompassing but poorly optimized solutions are increasingly prioritized in the industry.
One way to achieve high development productivity without falling into the trap of accumulating technical debt and needless overcomplication of the technology stack is to build applications that are scalable and flexible on the platforms where they can be deployed.
Another crucial component of productivity improvement is prioritizing software development frameworks and libraries that were designed to enable high performance. Integrated software development toolchains such as Embarcadero’s RAD Studio approach this task from multiple angles, supercharging developer productivity by reducing code complexity, fulfilling business requirements, providing application flexibility, and solidifying product performance.
Can You Improve Software With Less Code?
If we had to come up with a list of the most important principles for a software developer to uphold in order to be successful in the unfolding new era of digital technologies, recognizing the importance of writing less code would definitely take one of the top spots.
Successful developers know that reducing code length is the way to be more productive and minimize the development time in a smart, strategic way. It also allows businesses to keep their systems sustainable long-term without snowballing maintenance costs.
Successful developers know that the "less code" paradigm allows for the reduction of excessive complexity and makes the technology stack easier to understand for everyone.
Successful developers know that writing less code is necessary to keep the costs of software testing and maintenance that are quickly rising today under control.
Embracing simplicity and avoiding unnecessary complexity is an essential requirement for achieving high productivity going forward. Developers can apply these principles by using easy-to-read, -write, and -learn programming languages; adopting low-code technologies; and utilizing robust toolchains that were initially created to address the above-described issues and ramp up developer productivity.
Embarcadero’s RAD Studio has the "less code" idea as one of the fundamental principles of the platform. It aims to equip developers with a combination of an easy-to-read, -write, and -learn language; integrated toolchains; low-code technologies; and multi-platform deployment, ultimately being able to fuel a developer productivity boost up to X5.
Are You Ready to Embrace a New Era of Productivity?
As the developer productivity drain crisis is worsening, we will inevitably witness even more manifestations of this problem in the near future. Adopting a smarter approach to building, testing, and maintaining software products without further delay is the way to avoid falling into this trap.
Are you ready for the transition to the future of software development? Try RAD Studio for free or request a demonstration of this product.
