Do you remember when you were eight and your parents weren’t sure if football was the career of applied energistics grindstone for you? They told you that it’s okay to experiment with different things and figure out what really makes your heart feel alive. You agreed, but honestly don’t know what they’re talking about?
Well, think back to this moment of heart-to-heart vulnerability between parent and child. Now realize that they were actually being honest. In college, just like in elementary school, there are many things to try before settling on a major or career path. This post is not another one of those “Software Engineering Will Make You Rich” posts.
1. No one cares if you don’t like debugging
You will dislike debugging. You will strive to write code that doesn’t need debugging–code that is self-describing and self-validating. This is not always possible–all code needs at least one line of debug print every time it’s run.
What you will find out is that everyone else dislikes debugging too, and they feel exactly the same way you do when they must debug your buggy code. So don’t worry about it.
2. Learn x86 Assembly Language, but not just because I told you to
Learn the concepts of object oriented design before your brain becomes too indoctrinated into the practices of Java or C#. You’ll end up with fewer headaches and become a more flexible programmer.
Learn assembly language because debugging is easier and there are no garbage collectors. Also, if you program SPARC or Alpha targeted hardware with Solaris as your operating system, you’ll learn how to use “dis” (display instruction) to see what the processor is really doing when your program executes.
And finally, when you’re ready for a new language, such as C# or Java, you’ll find them easier to learn because of your place in the natural progression from machine code to high-level compiled languages.
3. Learn object oriented design before you hate it
You will hate the complexity of object-oriented programming, but you’ll become much better at it when you’ve spent all the time necessary to get a clear, comprehensive understanding of how objects and encapsulation fit together. Don’t wait until your classes have hundreds of methods–start small.
You won’t believe how many things in your apps are just copies and rewrites of other code. Take the time to define interfaces so that you don’t leak implementation details into your method signatures (and don’t worry about polymorphism or inheritance for now–those will come later).
4. Learn x64 Assembly Language
You don’t have to understand the underlying x86 instruction set first. You’ll find out that x64 assembly language is pretty much the same as x86 assembly language except that everything is bigger and there are new instructions. So don’t worry if you can’t remember everything at once.
5. Be aware of your work-life balance, but don’t obsess over it
It’s easy to get enamored with writing code and then staying up late to finish the job. You’ll love getting that rush of endorphins when you save the file for the 100th time and realize that your code works. But at some point you’re going to feel burnt out. And that’s when you’ll say to yourself, I really just want to go home for the day.
6. You will love the process of debugging, but hate the result of it
No matter how hard you try, bugs will always be in your code. This may become a source of frustration for you, but don’t give up on it yet. The challenge of debugging code is similar to that of solving a puzzle–you get deep insights into how things work and what needs to be done to make them work right. And then after overcoming a big bug? You are very high on life and feel like nothing can take you down!
7. Don’t wait to start looking for a job or to apply for a graduate program until next month
Now is the time! There is no sense waiting until you’re ready. If you don’t learn how to get a job in this software development class, you’ll find it very hard to do in any other classes. The most important thing in your life right now is learning how to think like a software developer and learning how to write code.
8. Don’t wait until your first year of grad school to start programming again
Start writing simple functional programs that compile on the angle brackets immediately–it’s easier than you think.
Remember, you don’t have to read a thousand pages of programming language specification or design patterns. Just get some code that works.
9. Get experience as soon as possible in a professional development environment
In this case, “development environment” means a place where you write code that someone else will use (not just for your own classes). It can be in a computer science lab with other academic programmers. It can be for the school. It can be for the city government or non-profit or private enterprise.
The goal of these environments is to learn how to work with other people on a regular basis and, more importantly, to learn how to communicate effectively in all sorts of circumstances.
10. Learn about the tools that make software possible
This means learning how to use Python and the command line–not just for debugging but for developing, too. You’ll find out that it’s not just a way to get your job done quickly; it’s also an excellent tool for learning how software is put together and fixing your own code when something goes wrong .
“You will hate your job…” is not a useful prediction. You’ll love your job–just as long as you pay attention to what you’re doing and learn as much as you can along the way.
“No one cares if you don’t like debugging…” is also not a useful prediction. You will dislike debugging and become a very good debugger–if that’s what you want.
“Learn x86 Assembly Language, but not just because I told you to” is also not a useful prediction. You’ll get more out of it than it will ever give you, even if you really only end up using assembly language much less than what I suggested.