By May 20, 2021

Programmers Are Going to Be OBSOLETE or Are They

Today we're going to talk about whether or not you should be worried about the changing nature of programming jobs. Especially all the automation that's happening, right?

This is the way that technology has always evolved, and that it will continue to evolve that way.

So there are two points that I'm going to talk about here that I think are very important.

Transcript Of The Video

John Sonmez: What's up guys. John Sonmez here from SimpleProgrammer.com. Today we're going to talk about whether or not you should be worried about the changing nature of programming jobs. Basically all the automation that's happening. This is the way that technology has always evolved and that it will continue to evolve that way. So, there's two things that I'm going to talk about here that are, I think, are very important. I've seen some other people do videos on this topic, and I think they've missed these very two important points.

If you're just joining me for the first time, I'm John from SimpleProgrammer.com. On this channel I teach you the soft skills you need for your software developer life. How to become a better person, how to become a better programmer and live a better life as a software developer. Everyone teaches all these technical skills and that's great. And I did as well, but I feel like the soft skills are sorely lacking. Click that subscribe and to join us. And also if you haven't checked out my books, I've got a book called The Complete Software Developers Career Guide. It was a Wall Street Journal bestseller. I think the only software development book to ever be on The Wall Street Journal bestselling list, as far as I know, and The Software Developer's Life Manual, both of them you can get on Amazon.

All right. So, there's two things I want to tell you about that I think a lot of people haven't covered about this. The first one is that historically what's happened is that technology has been built on top of technology and you sort of have this abstraction layer that you operate at and then software developers or coders or programmers start writing at that level. So, initially, if you think about the history of software development and programming languages, it started out with very low level languages. With assembly language. With basically twiddling bits, flipping bits, writing assembly language. And then what we ended up happening was compilers that allowed us to write at higher level languages. And then eventually to the point where another level of abstraction, which is object oriented programming. Languages like first C++, and C# and Java and things like that, that allow us yet another layer of abstraction.

But what you need to realize about that is that we still need to go down to the lower levels at times. And there's always going to be programmers that need to do that. In fact, Cobol is still a programming language that is in high demand. So, you're never going to escape those things. And there's always going to be legacy systems, but what will likely happen and what I know will happen is that we'll start writing code, we'll start programming, combining things at higher and higher levels. At some point there's going to be another layer of abstraction and you're not going to really see it happen, but eventually it'll happen where you're no longer writing code in the way that you write code. It will be more of combining systems together, but there'll still be the logic.

You'll still have loops. You'll still have conditionals. You'll still have all of these sort of mechanics that exist in the logic that ultimately underlies programming. And the reason why I know this is because even if you go down the stack to the lowest, lowest layer, ultimately even at the level of the registers in the CPU, it's still that same logic. It still comes down to the ands and the ors and all of the same level of logic, it's just that we program at a higher and higher level abstraction. So, the reason why I'm saying this is because there's always going to be programming jobs. You're never going to not have programmers, because you're always going to have to need to put things together and have to have logic. No computer is going to make all that logic. Now there's pieces of it that will be created and reusable pieces that will make it so more people can access that.

But ultimately combining them together, there's going to be someone that is going to say if this, then that. Now the second thing that I think is important to realize about this is that you're always going to have the software that builds up the higher levels. So, think about it this way. You're always going to have an operating system. And that operating system is going to have to work at the lower level. There's no way that you can have that code that runs the OS code that isn't programmed. There's certain things that you can build. Like you look at tools like Wix or Salesforce. Well, so far and I think that we'll never really hit the point where you can create Wix within Wix. It's different than … I remember the story of Turbo Pascal being created.

I believe that in the story of that, there was a point where there was enough of the language implemented that they could implement the compiler for the language in the language. And that's probably the story for many programming languages, but that won't happen with tools like Salesforce and Wix and things like that. You're never going to get to the point where that kind of code is going to be able to be created from it because it's designed to do something different. What we've seen in the past is programming languages that have evolved to a higher level, but they were designed to actually create the code and the logic. They weren't designed to do something functional. They're designed to be Turing-complete languages in themselves. So, when you have a Turing-complete language, it can operate at a higher level and essentially bootstrap itself and create itself, because it's Turing-complete.

But when you look at software like Wix, for example, it's designed for specific functionality to create webpages or Salesforce, which is designed to be a CRM system. And you look at all these kinds of drag and drop editors and things like that. They're not designed to actually create logic and to be Turing-complete. So, it's a totally different thing. So, the reason why that's so important, and I think a lot of people have missed in talking about this, is because that means that there's always going to have to be programmers that create that software at the lower level. So, it is possible, it's conceivable that lower level programmers, that there may be less of them and that there'll be higher level integration type of programmers that are integrating systems together through APIs. And a lot of it may be more drag and drop and connecting pieces here and understanding what the technology is.

But there'll always be low level programmers. There'll always be programmers that have to operate at that lower level in order to build those software systems. And as things evolve and technology evolves, and you have more automated systems and ways for people to build software without having to write code, there's going to be more programmers that have to create those systems and maintain those systems. So, that skillset will always exist. It's never going to disappear. What you may see is, and you're already seeing this, is a reduction in the number of web developers that you need to create web pages. So, that kind of code is not going to be as necessary, because people can drag and drop. They can create websites on their own. They can create payment processing. That's already been done. And that's a good thing. It allows technology to move forward. But think about also, I'll give you kind of a bonus one here, is think about some of the cutting edge type of technologies, think about AI and self-driving cars and where we're going in that direction.

And those things are not going to be drag and drop. Those are going to require programmers to define, to create that logic, to build those systems and the next level systems above that. Now, maybe we get to the point where AI is smart enough to actually write code and to come up with logical systems or to solve problems like that. And then maybe things shift, but we're still pretty far from that. And I would say that even in that case, there's still going to be some kind of way that things are going to have to be combined and created and programmed. But if AI gets to the point where AI can actually literally write code and figure out the logic of code and solve problems in that way, then pretty much every single job is going to be negligible.

It's not going to matter anymore, because accountants, bookkeepers, lawyers, all of these things could be solved by that same kind of AI. So, looking at programming specifically and saying, technology is going to erode it. It doesn't make any sense. It doesn't make sense. So, I wouldn't be worried about it, but what can you do as a software developer, if you're worried about this problem or to prepare for the future? Well, the best thing that you can do is that you can create a very specialized niche that you're good at. Figure out some technology, figure out some platform, some specific thing so that even if a lot of the jobs disappear, your specific thing that you're really good at, that you're going to get hired for that. That's really important to do. Being a generalist, just being a programmer.

There's some use to that, but as those jobs may be compact and there's less of those general jobs, but there's more specific jobs, then it's not going to be as high demand. Just being able to do web development, for example, it's not an extremely useful skill at this point in time, because people can say, well, I can drag and drop and create a webpage. But if you can do low-level programming, if you can design systems and combine systems and interact with APIs, or you have a very specific platform that you can work on or operating system that you can work on at the low level, driver code, all these things, those things are always going to be needed. And you can make sure that you have a demand for your services all the time. Let me know what you think. Are you afraid of losing your job to AI? Leave a comment below and let me know what you think.

About the author

John Sonmez

John Sonmez is the founder of Simple Programmer and a life coach for software developers. He is the best selling author of the book "Soft Skills: The Software Developer's Life Manual."