I remember my first years as a professional software developer, as a heady and exciting time.
I got lucky getting my foot in the door with my first developer gig. I never intended to get into the field of software development, and didn’t graduate with a traditional computer science degree in college.
However, what I did possess, was the PASSION to tinker with computers. As a young teen, I begged and pleaded with my parents to get a home computer system.
You have to keep in mind this was way back in the early 1980s at the dawn of the personal computer age. Personal computers that everyday people could buy and use in their homes was still a new concept back then. Most computers were larger mainframe systems owned by universities, government agencies and the military.
My parents, bought me an 8 bit, 1mhz processor speed Commodore 64 home computer with 64k of ram.
It’s probably a little hard to appreciate just how minuscule 64K of ram is. Modern day smartphones like a flagship iPhone or Android phone come with multiple GIGABYTES of ram. Not to mention processor speeds on those same smartphones are reaching 3 gigahertz speeds and beyond … people pretty much carry supercomputers that can fit in pockets and purses with plenty of room to spare.
Even with such primitive specs, that little Commodore 64 home computer ignited a seed of passion in me, about technology. Baked right into that little home computer was a built in BASIC programming language environment. You could immediately start typing code and with the blessing of the programming gods, the computer would actually execute your code instructions.
I can’t overemphasize just how exciting that first feeling of success was. I’m of the belief that FIRST feeling of excitement when someone sees their first computer code successfully running on a computer, is the initial catalyst that launches many a professional software developer’s career.
To this day, I continually strive to capture that first magical feeling of excitement when I first discovered the possibilities of computer programming.
- It helps motivate me to keep my developer skills sharp
- It helps maintain and grow my passion and enthusiasm for software development
The Importance of Staying Sharp as a Developer
I’ve hammered this point home in previous blog postings and articles, but I’ll restate it again. It’s one of those mantras you hear a lot in the overall field of software development.
“The only constant in software development is CHANGE.”
I’m reaching twenty years of professional software development and I can truly attest to this maxim.
When I first started my professional software development career, back in the mid 1990s, I wrote software that lived and ran natively on a client’s desktop computer.
If a new customer wanted to run my software application, I would actually have to physically walk over to the customer’s computer, and manually install my software on their machine. Multiply that by the total number of customers who wanted to use my custom applications, and you can imagine a big portion of my work day consisted of software deployment and installation.
But the internet was already quickly taking off in popularity and that traditional client-server desktop programming model was also quickly getting replaced by a NEW internet application programming model.
The internet revolutionized the way you could write and distribute software. As a software developer, I could now write my software as an internet application and deploy it to a centralized web server.
The only requirement a customer needed to execute my software was an internet web browser. Most operating systems already bundle internet web browser software, so the customer usually doesn’t even have to worry about installing a web browser.
No more manual installation of my software to customer’s machines. Better yet, with the new internet application programming model, I could make changes to my software, deploy my new software only ONCE to the centralized web server, and anyone who revisits my internet application INSTANTLY sees the changed results.
To this day, this internet programming model has survived and thrived and has created new software company giants like Google and Facebook, which solely develop applications that run on the internet.
Of course, this was a HUGE change in software development. While it offered some great benefits to the developer, such as the ease of software deployment, developers like myself had to learn new skills and ways of thinking about software development.
We had to learn about the HTML protocol. How web servers worked. Learning the difference between client side and server side programming technologies. Dealing and wrestling with the “stateless” nature of an internet application.
The constant changing landscape of software development means software developers like myself need to be aware of other changes as well.
Lots of new scripting and programming languages have been added to the field of software development. Near the beginning of my professional software programming career, I witnessed the introduction of a new programming language introduced by Sun Microsystems called “Java”.
Not many years later, Microsoft introduced a similar and competing computer programming language and framework called “C#” and “.NET”.
Did I have to learn every single new programming language as they came out? Certainly not.
In fact, most software developers eventually settle into a particular programming language and technical stack and stick with it for the rest of their programming career. There are some grizzled veteran programmers at my current employer, who continue to primarily write code in Pick Basic and have been for thirty years, and counting! (I actually had to look up Pick Basic on wikipedia to learn what it was!)
Yet I think it’s important as a software developer to at least be aware of some of the newer languages and technical stacks … you never know when new business strategies dictate new technical directions. Sadly, I’ve personally witnessed some of those veteran programmers get let go from a company, because they were unwilling to stay up to date with current technologies.
Yet another aspect of software development that continually evolves is HOW we tackle programming.
During the early phase of my professional career, I wrote code in a PROCEDURAL methodology. I would write METHODS and PROCEDURES, which were small units of code that could be called from other locations in my code.
But procedural programming was overtaken by a new programming paradigm called Object Oriented Programming.
As an OOP programmer, you would break down code into OBJECTS. Say you were tasked with writing a software application that tracked sales orders. You could design an object that represented an INVOICE object. Inside the INVOICE object, you could embed a different object that would represent a LINE ITEM, that would represent whatever was purchased on the INVOICE object.
OOP helped programmers to think about writing software at a more human level. We humans find it much easier to process information in real world human concepts like objects than we do as binary 1s and 0s, which is how computers ultimately process data and information.
Again, this was a pretty major shift in software development methodology. It was quite the struggle for me to adjust my thinking from a procedural programming methodology to the OOP paradigm. And it took quite a few years before I really felt comfortable programming the OOP way.
Was it worth the effort? Absolutely. The job market doesn’t stay still and soon most software shops required OOP programming skills.
To stay relevant and marketable as a software developer, you need to be aware and accepting of these continual changes in the software development landscape. There’s simply no way to fight it. The ones who fight it, ultimately get left behind.
Strategies to Maintain your Skills and Passion as a Software Developer
I believe there’s several strategies to help maintain and grow your enthusiasm and passion in software development.
Many developers, including myself, work on personal software projects outside of our regular work duties. I know some fellow developers who work on personal side projects in the field of mobile smartphone and tablet development. Other developers I know work on robotics projects that combine software and hardware programming skills.
Working on personal side projects often require new knowledge and skills. You’re literally forcing yourself to acquire new skills to help you finish your project.
Most metropolitan areas sponsor technical user group meetings in a wide variety of fields. In my own city, there are a large number of user group meetings in mobile application development, IoT (Internet of Things) development, functional programming, .NET programming, NodeJS/MEAN stack programming, the list is practically endless.
These user group meetings often present cutting and bleeding edge technical trends, concepts, new ways of tackling software development.
Not to mention the social aspect of meeting with other like minded individuals who share the same technical skills, experience and enthusiasm that you possess.
There’s almost no excuse NOT to enhance and grow your technical skills and passion for software development.
You have the entire internet at your disposal to learn about new technical skills, programming languages and frameworks.
You can participate in online technical communities like stackoverflow and interact with fellow developers.
You can join the open source community and begin contributing to open online source code community repositories like github.
Lots of companies are starting to sponsor hackathons where you can participate and work on your own personal “skunkworks” projects that you’ve always wanted to work on, but never had the time to. The company is literally PAYING YOU to work on your personal projects!
And of course, there’s a wealth of user group meetings where you can network and learn about the latest technical trends.
Doing something you love AND getting paid well for it.
Is there any better combination?