In the beginning...

I've been a software developer for close onto 40 years.  Yes you read that right, 40 years.  I was extremely lucky enough to have had gotten access to a ZX Spectrum 48K when I was 12, and basically was reeled in hook, line and sinker into the creative world of software development thanks to Spectrum BASIC, and a highly over active science fiction addiction. 

From the early days, unbeknownst to my young teenage self, I was getting actively involved in writing programmes to capture user data, process it and produce real world, useful, functionality from it. Initially this took the form of writing small programmes to allow my Bridge addicted mother to compile results from her competitions, and produce leader boards. Then I started writing programs form my older brothers AV company. Everything and anything from graphic adverts for events on big screens (big screens at the time that is) to invoice processing. I also was developing inventory maintenance and sales systems for local businesses who wanted to be pioneers in the integration of computers into their small businesses.

So from an early age I was extremely lucky enough to know exactly what I wanted to be in life: A software engineer.

I entered college at a distinct advantage in my software engineering course,  having already been developing actual real software systems for several years. Needless to say I loved college and excelled there. Again, I was just lucky enough to have figured out what it was I enjoyed doing in life at a young age. When that happens, everything tends to align beautifully. The universe comes on board!!

In college, even though it was back in 1989, there was always a discussion at some point about AI and how it would affect our chosen career path.  The general consensus was we were a good 30 years away from anything that would resemble the AI that films such as 2001 A Space Odyssey was showing. 30 years! In other words, who knows!  But I think the general consensus was that it would come at some point. 

Despite AI being a long way off, the bigger debate back then was in around 'intelligent' IDE's, or development environments and third generation languages.  Originally folks wrote software in machine code which was incredibly slow and 'traumatic' to work in.  Next came languages such as FORTRAN and BASIC, scripting languages that brought a human readable syntax to handle all those binary switches and flags.  Next up came much more complex languages such as C and C++, which was what we primarily worked on in college.  I think that the  general belief at the time was that as the languages evolved they'd eventually reach a point where they'd become so intuitive that any one could use them, and THAT would replace us software engineers more so than the emergence of AI.

That never happened.  Languages did evolve of course, but if anything, things got more and more complex as concepts around object orientated computing came into being that brought with them an even higher dependency on properly trained software engineers.

The years rolled on. College graduation came and went. I was employed by two different companies in my first 5 years of my professional software development journey, but my true passion was always just to work for myself and be the author of my own destiny so to speak, so back in 1996 I founded Sulware and never really looked back.

Software engineering 101

Throughout the years, there are two critical skills I believe that software engineers need:

1. The ability to be able to listen to and communicate with clients on a human, real world level. 
   So in short:
   • Be able to talk to clients and ascertain a concise and accurate set of requirements
   • Be able to come up with a system design that the clients can understand and buy into before any code gets written
   • Development of a system that does exactly what the design expressed leaving the client with exactly the application that they were told they were going to get.
     
     
2. The ability to constantly retrain.
   To be a good software developer you have to not only be able to accept change, but embrace it. You have to love the journey entirely.  

So, lets focus on point 2.

Retraining has been a key part of my journey throughout my career.  From the moment I first opened the ZX Spectrum box back in 1982 to today, not a week goes by when I'm not picking up a new development skill.  It is relentless.

Once I've worked out a system design for a client, and I eventually get to lock myself into a room to work on the actual application development, the process has always been pretty much as follows:

1. Write code
2. Run into an issue.
3. Research how to get around the issue
4. Back to step 1 and repeat until the application is developed.

In the good old days, step 3 tended to involve a library of books. All types of development books. C++, C#, Java books. Software development and design books.  You'd spend hours, days trying to get around some problems this way. Buried in books and slowly building a comprehension for a new way language feature or a new design pattern to use. It was a time consuming but necessary process.

As the internet blew up, things changed.  Books moved online, and chat boards, and chat rooms came online where software engineers all around the world could share their knowledge. And they were extremely willing to do so. That's the thing about software engineers in general, there's a strong willingness to help each other which is very encouraging from a humanity perspective! :)  I remember facing challenges with some solution and posting on a developer board, waiting a day or two and then getting detailed responses from colleagues from the other side of the world. Thrilling.

Eventually google came along, and the trick now was to be able to parse  google search results.,   Search results would be of a wide and varied quality. It took time but still was an awful lot faster than going through books.

And things stayed like this for a long while, relatively speaking.  More focused and better organised developer boards or websites came online, such as Stack Trace and co., which provided a much more focused and quicker way of building on other developers knowledge.

Semantics Vs Syntax

Getting back to the above 4 steps I mentioned, these remained more or less constant.

Software tools got better, coding libraries got better, IDEs radically improved to allow for things like pre-emptive editing (IntelliSense) where the IDE would pre-empt the command you were trying to type and finish it for you. It would give you lists of methods that you could call for an object. Basically it was becoming a much more useful environment to work in.  We still ran into issues, but now the research had opened up significantly to allow for access to a massive base of knowledge and provide search tools to quickly work through that knowledge base to find the solutions we need.  So all in all, the fours steps remained, but things were quickly evolving at each step.

However, despite all of the massive and revolutionary changes that were occurring in this space there was a strong dependency on software developers.  In fact, software developers, if anything, were never so much in demand.  Software was everywhere. The mobile application space had exploded, and everyone had a highly complex computer on them the whole time that required complex software solutions.  Building these solutions required highly trained and experienced software engineers. 

Then in 2024, ChatGPT came along.

The birth of the Large Language Model (LLM) had happened.   These were actual real AI systems, built around massive amounts of data and neural network system that could quickly interrogate their data base and produce meaningful results from a truly free form, normal speaking, natural language query.

It wasn't long before talk started of how LLM's were about to revolutionise the entire software development industry. In fact, talk was switching to how, finally, AI was going to replace software engineers.  These LLM systems, could use code libraries such as Git hub, (where developers from all over the globe store their code repositories) as their language models, and then build entire software applications based on real world requirements fed in by normal, non software engineer users.

Well, I wouldn't quite say we're at that point. Not yet.

The reality here is that these LLMs have absolutely, radically changed the development environment.  However it's more of a software evolutionary leap as opposed to a full on replacement.   Lets get back to step 3 in our 4 step process again.  That step, research a solution, moved from developers reading tech manuals, to putting queries on online boards, to Google searches and sites like Stack Trace.  Each of those steps, I'd argue was an evolutionary leap.  And now, we have LLMs which are providing the next evolutionary leap in this part of the process.  

How does this work? Well, again, I'm writing code. I run into an issue and now instead of using Google to help me find a list of possible solutions, I ask ChatGPT or CodePilot to help find a solution.  Now, there's no search results to sift through. Now these systems literally will generate a solution right into my development environment for the problem I'm facing, radically decreasing the time it takes to typically get through this process. 

It's absolutely amazing.  

Furthermore these LLM's are integrated into the heart of the development environment.  Now instead of the IDE giving a list of possible commands that the developer is trying to do, the IDE is suggesting entire chunks of code that the user can choose to integrate immediately. It's literally generating the next 5, 10 or more lines of code based on what I'm doing.  It knows generally what the purpose of this function is that I'm writing, and suggesting how to do it.  It's radical. It's revolutionary, and in most cases is for the best part largely accurate and correct. 

That last part is REALLY important.
It's LARGELY correct.
I'd say probably 85% correct most of the time.  But I rarely can compile what the LLM comes up with without any issues. 

And don't get me started on the actual number of times that AI actually, just, well, makes stuff up! Seriously! They call it AI hallucinations and when that happens you can go down crazy rabbit holes for hours if you're not careful and paying attention.

So I really need to be on top of what the AI is doing and recognise and correct things when they go wrong.  In most cases, for any complex code, it becomes an iterative process between myself and the AI tool where it generates code, and I modify it and correct it before we can get to the final version of code required. It's a true collaboration. Almost like two developers working on the project. The more you understand as a developer, the quicker this overall process becomes.

In short though, I'm still needed.

So far.

In fact, I'd argue that the LLM requires a pretty seasoned developer to work with in order to be able to understand the code the LLM is producing, and be able to correct it and move on.  The LLM can quickly write a lot of the code that would take me longer to write, but I can provide the experience and skills to correct the LLM where it's going wrong.

However working with the AI tool results in a much more rapid and enjoyable development process.

What these LLM's are doing right now, is providing an amazing, and essential, tool in my developer toolbox.  

So is AI going to replace software developers?

Maybe, one day, but not just yet. Right now, it's just an incredibly productive development tool I can use to help me cut down my development time and help me stay on top of latest development trends, while at the same time produce tighter and more robust applications.