Programming Evolution: How Coding Has Grown Easier in the Past Decade – ITPro Today

Programming is an ever-evolving discipline. In some respects, it evolves in ways that make coding more difficult. The shift to cloud-native architectures, pressure to achieve flawless software performance and similar trends have made the job of programmers more difficult today than ever before. Yet, in other ways, programming has become easier, especially during the past decade or so. To understand what it means to be a programmer today, it's worth surveying programming evolution in recent years to appreciate which aspects of a coder's job have grown much simpler.

One programming evolution trend that has simplified programming is the proliferation of open source code.

There are now millions of repositories of source code out there that anyone can legally download, modify and incorporate into their own programs. For some programmers, this means it is easier than ever to build out applications quickly by borrowing code written by others.

Doubling down on this trend is the fact that open source today tends to be governed by relatively liberal licenses that give programmers maximum freedom to reuse it in any ways they want. That was not the case 10 years ago, when stricter licenses like the GNU General Public License (GPL) predominated.

The reuse of open source code does come with its downsides, of course. It's impossible to guarantee the quality and security of code written by third parties unless you vet it yourself. In that respect, programmers who borrow from open source projects face more work.

Still, it's hard to deny that the ready availability of such an astounding amount of open source code hasn't made programmers' lives easier in some core respects.

What if you want to build an application quickly, but you can't find ready-made open source code to do it with?

The solution may be low-code (or no-code) programming techniques, which allow developers to write applications quickly by taking advantage of prebuilt modules and automatically generated code.

To be sure, low code isn't the right approach for every project. Low-code applications tend not to achieve optimal performance, and, as with the reuse of open source, developers need to manage the security issues that may arise when they use code generated by low-code platforms.

Nonetheless, if you had asked developers 10 years ago to imagine a programming evolution in which programmers could automatically generate much of the code they need to build their applications, they probably would have been incredulous. After all, earlier efforts to create something resembling low-code platforms enjoyed little success. But, today, that approach has become routine for many programming teams.

In the past decade, APIs have played a huge role in the programming evolution. It's easy for developers to have a love-hate relationship with APIs. APIs create additional security risks that programmers need to manage. They often place limits on which functionality you can implement within an API-dependent app because you can only do whatever the API supports. And APIs can become single points of failure for applications that depend centrally on them.

On the other hand, APIs make the lives of programmers easier in the sense that they make it fast and simple to integrate disparate services and data. Until about 10 years ago, if you wanted to import data from a third-party platform into your app, you probably would have had to resort to an "ugly" technique--such as scraping the data off of a web interface. Today, you can easily and systematically import the data using the platform's API (assuming it offers one, which most major platforms do today).

In short, while you could argue that APIs have complicated the work programmers do, they have done much to simplify the implementation of applications that need to integrate or interact with multiple external resources.

Perhaps the biggest driver of programming evolution has been the rise of modern standards.

Until about a decade ago, not only were there relatively few open standards that major vendors supported, but companies often went out of their way not to make their platforms compatible with those of external organizations. This meant that programmers had to write different code for each platform that their apps needed to support.

Fast forward to the present, and even companies that were once stalwart opponents of shared, open standards have changed their ways, making it much easier to build applications around a core set of standard frameworks.

For example, take OpenTelemetry, a framework for exposing and collecting observability data from applications. Using OpenTelemetry, developers can write applications that work seamlessly with any monitoring software that supports OpenTelemetry. That beats having to implement different instrumentation for each observability platform that you want to work with.

Another example is Open Policy Agent, or OPA, which provides a single policy-as-code framework that can be used across most mainstream platforms. Instead of having to use a different policy framework for each service, developers can standardize around OPA.

For some programmers--some of the time, at least--programming today is considerably faster and easier than it would have been just 10 years ago. Despite the ever-increasing complexity of applications themselves in the last decade of programming evolution, developers today can lean heavily on open source, low-code platforms, APIs and open standards to make some core aspects of their jobs easier.

More here:

Programming Evolution: How Coding Has Grown Easier in the Past Decade - ITPro Today