4 Software Programming Challenges for Today’s Developers

How daunting are today's software programming challenges? By many measures, software program is harder today than it used to be.

True, programming today is not harder in all respects. Modern programmers benefit from a litany of tools--like web-based source code managers, low-code platforms and automated release management tools--that few developers could have even imagined 10 or 15 years ago. Programming languages, too, have generally become more user-friendly over the decades.

Yet, when you think beyond tools, there are many ways in which software programming challenges are bigger today than they were for developers' forebears. From complex architectures to security challenges and beyond, it can be significantly more difficult to design and write software today than it was in the relatively recent past.

To prove the point, here's a look at four software programming challenges that are affecting developers today.

1. Complex Application Architectures

Perhaps the most obvious reason why programming is more challenging today is that applications, and the codebases from which they are built, are much more complex.

Most developers would probably agree that it's easier in most respects to work with monolithic code than with microservices. When you're dealing with a monolith, you don't need to worry about whether a change in the code for one microservice will break another one. You also don't have to write code that allows all of your services to communicate with each other across whichever highly complex stack of abstraction layers you are deploying them on.

But today, microservices have become the go-to architecture. That means programmers have to contend with more complex service integrations and dependencies. They must also manage software delivery pipelines that consist of more moving parts because they have to ship updates for each microservice separately, all while ensuring that the app as a whole doesn't break due to a problematic update.

So, yes, microservices offer lots of advantages. Unfortunately, an easier programming experience is not one of them.

2. Heightened Security Expectations for Developers

Good developers have always cared about security. However, for the past decade--when each year has set new records for the frequency, severity and financial impact of cyberattacks--the expectations placed upon developers when it comes to security have grown much more intense.

Now, developers have to think about the security implications of every line of code they write just as much as they consider the feature and performance implications. They are also expected to embrace the newfound concept of DevSecOps by collaborating closely with security analysts and "shifting security left" (and/or right)--something that also did not usually happen 10 years ago.

Again, this doesn't mean that developers in the past didn't care about security or try to write secure code. But what has changed is that security has shifted from being one item on a list of developer and business priorities to perhaps the key item. Particularly for developers who don't have a security background--which most don't, given that computer science programs in the past tended not to place security front-and-center--that makes development work considerably harder.

3. New Environments: Cloud, Kubernetes and Beyond

Once upon a time, a good full-stack developer knew the ins and outs of both Windows and Unix-like environments. That's what it took to develop software that could run basically anywhere.

Today, developers need to know not just Windows and *nix, but also AWS, Azure, Docker, Kubernetes and all of the other layers of technology that may play a role in hosting their applications. Oh, and don't forget iOS and the various iterations of Android, if you need to support mobile.

This means that there is simply much more for developers today to know about deployment environments. The idea that you can "build once, deploy anywhere" sounds great, but it works only if the developers who write the application can design it to run on any of the various operating systems, clouds, orchestrators or combination thereof on which it may be hosted.

4. Less Control and Customizability

In addition to increasing the learning curve for developers, cloud platforms have also reduced the level of control that developers can expect to have over their applications.

In other words, your application can access only whichever APIs your cloud provider supports. You can collect only whichever metrics or logs the provider exposes to end users. You can work only within the access control framework it offers you.

This was not so in the past. When applications were deployed directly on operating systems, developers typically had more choice in terms of which libraries, frameworks and so on they used. And in the case of Linux, at least, they could customize the operating system itself to their hearts' content, if they wanted.

Today, then, developers need to figure out how to build apps that can run in a more diverse set of environments, but they have less ability to control and monitor those environments.

Conclusion: Increasing Software Programming Challenges

Being a programmer today is certainly easier in some respects, especially when it comes to the work of actually writing and deploying code. But, bigger picture, coding has become more challenging. Developers must now work harder to manage responsibilities related to security, complex application design, and the sprawling, diverse stacks of technologies on top of which they deploy their applications.