Are programmers safe from automation?

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.
Changes, changes, changes
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 be changed, 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:
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 needed to support asynchronous communication to process massive data and asynchronous communication is usually implemented with promises/observables and those usually consume functions, so programming languages start including lambda expressions. Containers enforce modularization, so programming languages start moving into modularization. And so on and so forth.

OK, we got it. But, what are the trends? What is the direction? My answer is automation. We are moving into the declarative programming. I see 2 things which become more and more popular:
- Annotations and “behind the scenes” approach,
- 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. Focus is moved to the higher level of abstraction. Every service is declaring its functionalities within the contract and that’s it. Scalability, fast time-to-market and technology independence are the main advantages here [ source].
And contracts are presented at the lower, programmer’s level as well:
- Popular Java frameworks, like Spring and Hibernate have XML configuration/contracts for a long time. Nowadays they support also configuration by annotations. And this works also for the front-end world. Angular is the evidence here.
- Annotations are not only for configuring. The less lines of the written code, the less bugs in the code. Annotations in , AsspectJ, Spring AOP and literally generate the code for us. And a related topic are things like Spring Repositories, which require just method names and the implementation happens automagically.
- Declarative/contracts approach is presented in Spring Boot, which is a mechanism for getting a preconfigured app (with all the libraries in their proper versions) based on our chooses.
- Declarative/contracts approach is presented in all the CLI tools and code generators like: Angular CLI, Yeoman or JHipster.
You declare what and it just happens. It is already here, especially for data model and UI (forms, views etc.).
Functional programming
On the other hand, we can observe the functional programming (r)evolution. One step forward from Microservices resulted in Serverless Architecture. There is a following way of thinking: “ Microservice shouldn’t do much, but should do it perfectly, so why not converting it into a single function?”.
Functions make sense, because we are using verbs at a daily basis to clarify our intentions. Just try to describe your morning routine without using verbs. In Polish language, we have even a differentiation between a “sentence” and the “equivalent of a sentence”. In short words — you cannot tell the “sentence” without verbs.

Core Java way of evolution is enough for me to accept this functional trend. Non-trivial business logic would be always described by verbs: “ calculate a premium ( add this, multiply by this, subtract that)”, “ verify the customer (e.g. check his shopping history)” and so on [similar opinion].
I believe that this functional thing can also be automated. Microsoft has already created AI which is able to code. Sooner or later it should be possible for such AI to code every simple function and then it would be a matter of dividing system into fine-grained functions in order 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. But, unlike in some reports, in my vision programmers are NOT safe from the automation. The automation already started. Every time someone uses JHipster or Spring Boot, he moves closer to the full automation.
The only thing programmers (including me) can do, is to adapt. You can sit and cry that escalator makes you fat, but it would be better to use it to walk faster instead. Thanks to the automation, programmers would be able to take a responsibility for more ambitious tasks. Programmers could become real human-machine translators. Without spending too much time 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 to the 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. Having all the automation, software should be developed faster and cheaper. And it should result in more systems in general. More systems require more testers, because each application, even the one created by the machines, would be used by the end users, humans in most cases. And testers are humans as well. I see the ordinary coders as the future technical testers, who are able to do small fixes and a tiny customization of an app.
So even a big automation doesn’t scare me. I see more advantages than disadvantages here. Either a more ambitious work or new job positions (for less ambitious guys). And 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?
Originally published at https://www.linkedin.com on July 30, 2017.
