Are programmers safe from automation?

I’m one of the "listeners" - I prefer reading over writing. But after reading and reading, I sometimes need to clear my mind by sharing my thoughts. And here comes the article.

Changes, changes, changes

I’m a software developer with a hands-on experience in various technologies, from back-end to front-end, including an integration layer. And, as other developers, I’m witnessing changes in the world of code.

2014-2015 I was a proud user of TypeScript and AngularJS combo. Then, I have like 12-month break from the front-end and came back to this in 2016. What can I say? I just agree with this article. It changed...

Technologies are always first to change, but it is not only about switching from language A to language B. Not even about new frameworks/libraries. Problems are even with the official versions of the languages. A couple of examples:

• I used to know C++ (no professional experience, but still). And I recently took a look at its Wikipedia description. I realized I don't know it anymore. I don't even know C++11, while C++17 is already presented.
• At some point in time there were plans to introduce Java 9 just 2 years after Java 8. And from version 7, its (r)evolution is pretty dynamic.
• JavaScript specification, ECMAScript, has now an alternative versioning convention to point out yearly updates. The newest version is ES2017.

All those syntax changes in programming languages are not the results of authors' fantasies. In my opinion, those are just obligatory things in the IoT, containerization, cloud computing, and Microservices era. It is necessary to support asynchronous communication to process massive amounts of data. Asynchronous communication is usually implemented with promises/observables, which often consume functions; thus, programming languages have started including lambda expressions. Containers enforce modularization, so programming languages start moving into modularization. And so on.

OK, we got it. But what is the main direction? My answer here is automation. We are moving toward declarative programming. I see two things that are becoming increasingly popular:

1. Annotations and "behind the scenes" approach,
2. Functional programming.

Annotations and “behind the scenes” approach

I've mentioned Microservices Pattern. With this pattern, IT architects should focus on the cooperation between the small applications. The focus shifts to the higher level of abstraction. Each service declares its functionalities within a contract, and that's it. Scalability, fast time-to-market, and technology independence are the main advantages here [source].

And contracts are also presented at the lower, programmer's level:

• Popular Java frameworks, like Spring and Hibernate have offeed XML configuration/contracts for a long time. Nowadays, they also support configuration through annotations. And this works also for the front-end world. Angular is the evidence here.
• Annotations are not just for configuration. The fewer lines of written code, the fewer bugs in the code. Annotations in Lombok, AsspectJ, Spring AOP and Feign literally generate the code for us. A related topic is features like Spring Repositories, which require only method names, with the implementation happening "automagically".
• The declarative/contracts approach is also evident in Spring Boot, which provides a mechanism for creating preconfigured apps (with all the libraries in their proper versions) based on our choices.
• Declarative/contracts approach is presented in all the CLI tools and code generators like: Angular CLI, Yeoman, and JHipster.

You declare what, and it just happens. It is already here, especially for data models and UI (forms, views etc.).

Functional programming

On the other hand, we can observe the functional programming (r)evolution. One step forward from Microservices has led to Serverless Architecture. The reasoning goes as follows: "Microservice shouldn’t do much but should do it perfectly, so why not convert it into a single function?".

Functions make sense because we use verbs daily to clarify our intentions. Just try describing your morning routine without using verbs. In Polish language, we even have a distinction between a "sentence" and the "equivalent of a sentence". In short, you cannot tell the "sentence" without verbs.

The core Java changes are enough for me to accept this functional trend. Non-trivial business logic will always be described by verbs: "calculate a premium (e.g., add this, multiply by this, subtract that)", "verify the customer (e.g., check their shopping history)", and so on [similar opinion].

I believe this functional approach can also be automated. Microsoft has already developed AI capable of coding. Sooner or later, such AI should be able to code every simple function, making it a matter of dividing the system into fine-grained functions to implement it.

Simple functions and contracts, and we are done.

The programmers of tomorrow

I really see the world where machines overtake people’s jobs. However, unlike some reports suggest, in my vision, programmers are NOT safe from the automation. The automation has already begun. Every time someone uses JHipster or Spring Boot, they take a step closer to full automation.

The only thing programmers (myself included) can do is adapt. You can sit and cry that the escalator makes you fat, but it's better to use it to walk faster instead. Thanks to automation, programmers will be able to take on more ambitious tasks. They could become real human-machine translators. Without spending too much on the implementation details, being sure the code follows all the best practices at the same time.

But I’m referring here to the ambitious programmers, not ordinary "coders" who currently earn a lot of money, while they do nothing but copying and pasting to create yet another similar thing (a part of the UI, an entity, a logging functionality, a process, etc.). Such coders are going to be fully replaced by the machines. Sooner or later.

But there is a light of hope, even for such coders. With all the automation, software should be developed faster and cheaper, leading to more systems being created. More systems require more testers, because each application - even the one created by the machines - will be used by end users, humans in most cases. And testers are humans as well. I see ordinary coders as the future technical testers, capable of making small fixes and performing minor customizations to an app.

So even significant automation doesn’t scare me. I see more advantages than disadvantages here: either more ambitious work or new job positions (for less ambitious guys). Plus, a faster time-to-market for everyone. But when? This is a separate topic...

And you, what do you think? Are programmers safe from automation?