5 things I had to teach myself about software development that school didn’t
I consider myself to be in a fortunate position at this point in my life. I recently moved out into a house with my girlfriend, I adopted three wonderful kitties, and more all during this pandemic. I was also very fortunate to keep my job as a junior software developer.
I started working as a junior developer around late August of 2019, right at the start of my junior year of college. We are a small, but growing managed service provider. Before then, I was (and still am) working on a freelancing project that kick started my passion for building software that school never could.
In starting my freelance project, I began to see that there were a lot of pieces to being in this field that school just doesn’t teach. Some of these things were reinforced when I started working and other new ones popped up. Some of the things I learned relate to technology and others not so much. Either way, the role of developer is now constantly changing and growing. Developers now do back-end and front-end, database administration, deployments, and more.
Now, as I enter my senior year of school, I would like to take a step back and reflect on what I learned from being in the field that school never did teach me. Here are the top five things that school did not teach me.
1. Language doesn’t matter, at least in the way you think
I remember sitting in these classes thinking “Wow this language is so great I’m going to use it for everything”. And unfortunately this is not how the real world works. Worse off is the teachers made each language seem like the definitive, best way to write software. My C++ teacher would rag on Java, and my Java teacher would rag on C++. It lead to a lot of confusion in what I should focus on.
Then once I started working and freelancing, it hit me. It doesn’t matter, or at least as much as you might think. The thing is, each language, framework, library, all has their place in the world of software. Want to quickly build and prototype a new application? There’s Python, Ruby, and NodeJS. Need a type safe, compute intensive application? Have a crack at Java, C#, or Go. Have to work at a hardware level where performance is a concern? Well try out C++ or Rust. Each one of these languages is the right tool for some kind of job.
When I started my freelance project, I had to sit down and look at what was needed. I had to think about scalability, time to develop, features they wanted in version 1.0 and wanted to add later on. I eventually settled on a Java Spring API connected to a PostgreSQL database. For the front end I settled initially on Angular, but I hit some limitations in it, so I moved over to React. The choices here were simple; all the technology is open source, PostgreSQL has a ton of features for me to take advantage of, Java and Spring let us build a rigid but scalable API that can do some serious processing very quickly, and React let us create a responsive UI that we can then turn and do things like Server Side Rendering and create a Progressive Web App with very easily. At work, we use .NET tools and libraries because it quickly allows us to build the products our clients need. What makes it easier is that most of them are on Azure and Azure SQL Server, so we can deploy their applications very easily as well as have a database that integrates seamlessly into our stack.
Lesson learned: No language is one-size-fits-all, each has their own strengths and weaknesses that make some better than others for specific tasks.
2. Git (or any version control)
Git is one of those things that I had to learn myself. It took me a lot longer than I would like to admit and I am by no means an expert in it, but Git is one of those things that would have been great to have learned as apart of some programming class. Instead, we had to zip up and submit our files that way. It’s not a bad way to manage applications in that setting, but really doesn’t teach you how or why version control is so important.
Version control is essential to modern software development. From small to large projects, it’s crucial to writing and maintaining code. In my own daily workflow, I create a project and push all the initial files to the master branch. Then I create a develop branch that contains all the initial files from master. When I go to create a feature, I create a new branch with that feature name. After I complete it, I merge it back with develop for testing to make sure it works with the any other features that were worked on. Then I merge with master and push to production. Here then I use tags to denote the version being pushed up. If a version starts failing, I can easily roll back to a version I know works.
Version control is really a skill that should be taught in school. As developers are taking on more and more rolls in the workplace, knowing this part of the software development life cycle is crucial to success in the workplace. It’s also crucial to helping developers get jobs. Putting your projects on a platform like GitHub is how potential employers can go and look at what you’ve done, like a portfolio for your software.
Lesson Learned: Git and version control is an extremely important tool for developing software and for building your development portfolio.
3. Client Relations
This one is a little less technical, but still extremely important to the life of a developer. In my schooling, client relationships were brought up in my Systems Design class, but only for discussing planning and for taking the plans and turning them into technical documents such as Entity Relationship Diagrams. It was more on the process and less on the client.
One of the first things I realized when I started building software for others is that everybody is completely different in their levels of understanding technology. Some people have a grasp on it and understand your technical specifications and can ask questions, others think you sit at your desk all day with a magic wand and pull things out of the air with the flick of the wrist without realizing how much time or process goes into actually building something.
It’s important to know this when dealing with anyone outside of software development. Sometimes you can geek out and discuss specifications in detail and other times you have to manage exceptions without talking about the tech parts at all. Sometimes you deal with bugs or issues for days and only have it come back as a user error. Things like that happen and that’s okay.
Some things that are important to remember are being open and realistic with the client, no matter if you’re in the planning, testing, or bug fixing stages of development. Don’t be afraid to speak up if you have an idea that you think may work better than what is being proposed, but be respectful about it. Understand who you are talking with and their level of technical insight. Having a healthy client relationship is key to making great software.
Lesson Learned: Managing and maintaining healthy relationships with clients is just as important as writing good code.
4. Deploying Software
Maybe this one is a little unfair, but seeing as how developers are having to take more rolls on and learn more skills, I think this is an important topic to touch on. This is more important than ever now with the advent and embrace of cloud computing. Developers are now needing to know how to deploy applications to the cloud, whether that be on AWS or Azure or Google Cloud Platform, this is skill is very important.
You just built a shiny new app and you’re ready to share it with the world. Now what? What do you go with it? You go online and lookup how to host a website. You now realize you need a domain, a cloud provider to host it on, setup Nginx or Apache to serve your pages, configure firewall rules and holy cow you’re going to explode. Now today, tools like Netlify and GitHub Pages make this so, so much easier to do so static sites, but what about sites that aren’t static?
I’m not saying cloud computing should be taught in school because there are so many providers with services and features. But I think, at least in Linux or Linux Administration classes, things like Nginx/Apache, where static files go, how to configure firewall rules, and all that should be taught. My introduction to Linux class focused a lot basic commands and RegEx. All of that is very important in doing work in Linux, but things like command line messenger systems really do not seem as important as knowing how to configure Nginx.
Lesson Learned: Again, maybe this section was unfair, but I think it’s important to know how to deploy your software, or at the very least, some different options for deployment and configuration.
5. How to write software
This may seem kinda stupid, but all throughout my schooling, I never learned how to actually write a piece of software. What I learned in school was syntax and theory, but not how to actually write software. In my five, almost six years of studying computer science, I have about 1.5 projects I would consider to be pieces of usable software.
The 0.5 one was a bank account management app in C++, except all the values in it were hard coded. There was not dynamic input and output and the logic flow was very clunky. You had to have it do specific things on specific dates, which again were events that had to be hard coded. The only full project I did was a Java FX text editor that could read files and be edited and then saved back out. It was completely standalone and had no database or configurations or syntax highlighting or anything fancy, but it made me feel good that I made it.
All the other projects we did were either completed with some fill in the blanks or just theoretical “this is how a for loop works under the hood” kind of examples. It wasn’t until I started freelancing that I began to understand how software all fits together. I learned about database connections, REST API’s, security practices, JWT tokens, and much, much more. I look at it like school taught me how to code and the real world taught me how to write software. Knowing how to write a LinkedList is very different from knowing where and how to use a LinkedList.
Lesson Learned: Knowing how to write code is not the same thing as knowing how to write software.
I know I keep saying it, but developers are taking on more and more roles and this is creating a divide in what schools teach and what people do in their daily lives. We need to know how to architect applications, deploy them, and version them. We need to know multiple languages and where they are useful. We need to know how to communicate with clients and how make what they want a reality.
Maybe I was unfair to our computer science curriculum in some areas and really, I did not mean to be. These were just some of the things that I had to learn myself when I started doing this in the real world. Things like Git were never mentioned in any of my classes, I thought I had to commit to learning one language and stick to it forever, I had no idea Cloud Computing or Apache or Nginx existed, let alone how to use them. These things are all really important in today’s world. It’s where things like bootcamps have really started to pickup in popularity, along with online courses on Udemy and Pluralsight. Those camps and platforms give you resources to learn how to do everything I had discussed before. It was how I learned to do these things.
Do curriculum's need to be looked at? Most likely. Colleges do have their value in computer science programs. For instance, it lays a good foundation in languages, shows you how and why things work how they do, and gives you access to things like clubs. But I do believe what they teach needs to grow and change to better prepare graduates for actually working in the industry.