Things All Developers Should Learn In College
Tags: javascript, beginners, webdev, tutorial
Published: 2019-07-15 14:16:00

---
published: true
canonical_url: https://www.cdevn.com/what-developers-should-actually-learn-in-college/
description: "What your professor won't tell you."
---

## Forget About "Lines of Code"

![](https://thepracticaldev.s3.amazonaws.com/i/vmbqyj278qt930ua7lxk.jpg)
<center>[Source](https://images.techhive.com/images/article/2015/09/historic_loc-chart-100615917-large.idge.jpg)</center>

As a developer, you'll hear a lot of crazy, unbelievable theories about what "lines of code" signify. Believe none of them. Lines of code is a ridiculous metric to base decisions on. In very rare cases it tells you something, in all the other cases, it tells you nothing. Using lines of code to make decisions is like rating book quality by number of pages.

Some might make the case that the fewer the lines of code there are in an application, the easier it is to read. This is only partially true, my metrics for readable code are:

* Code should be consistent
* Code should be self descriptive
* Code should be well documented
* Code should utilize stable modern features
* Code shouldn't be unnecessarily complex
* Code shouldn't be un-performant (don't write intentionally slow code)

The moment reducing the number of lines of code interferes with any of those, it becomes a problem. In practice, it will almost always interfere and thus is nearly always a problem. But here's the thing, if you strive to meet the above criteria, your code will be the perfect number of lines, **no need for counting.**

## Languages aren't necessarily "Good" or "Bad"

![disliked](https://thepracticaldev.s3.amazonaws.com/i/30fmha6zyrtfrt1a80i1.png)


<center>_Except for php, just kidding. [Source](https://stackoverflow.blog/wp-content/uploads/2017/10/languages-1-900x675.png)_</center>


I see people say stuff like this, all the time:
  
  > C is better than X, because performance

|
  
  > Python is better than X, because conciseness

| 

  > Haskell is better than X, because aliens

The notion, that a language comparison could be reduced down to a single sentence is almost insulting. They're languages, not Pokemon.

Don't get me wrong, there are definitely differences between languages. It's just that, there are very few "unusable" languages (although there are many outdated/dead languages). Each language brings it's own unique set of tradeoffs. In that regard, languages are similar to tools in a toolbox. A screwdriver can do what a hammer can't, but would you ever say a screwdriver is better than a hammer? 

> obviously the hammer is better

Before I talk about how I evaluate languages, I want to make something very clear. **There are very few cases where the language choice actually matters.** There are things you can obviously not do in some languages. If you write frontend code, you don't get a language choice. But in general, language choice is usually one of the least important issues for a project.

Here are the core aspects (ordered), that I believe should dictate your choice of language (these are it's Pokemon stats)

* Density of available online resources (StackOverflow density)
* Development Velocity (vroom vroom)
* Bug proneness (eeek)
* Quality and breadth of package ecosystem (yea npm, it says quality)
* Performance characteristics (more dots)
* Hirability (sorry COBOL)

There are also some strong couplings that are out of your hands. If you're working in data science, you realistically need to use Python, R or Scala (maybe Java). If it's a hobby project, use whatever will make you happiest. There's only one non-negotiable rule I have. I refuse to use languages that don't have most of the problems I will encounter, directly solved on StackOverflow. It's not that I can't solve it, it's just not worth the time.

## Reading Other People's Code is Hard

![reading hard](https://thepracticaldev.s3.amazonaws.com/i/5zog7djn2ajgazwyrliy.jpg)

<center>[Source](http://www.sph.as/why-bible-reading-can-be-hard-for-kids-and-what-to-do-about-it/)</center>

Reading other peoples code is difficult. Robert C. Martin talks about this in "Clean Code":

> Indeed, the ratio of time spent reading versus writing is well over 10 to 1. We are constantly reading old code as part of the effort to write new code. ...[Therefore,] making it easy to read makes it easier to write.

For a long time, I assumed that I just sucked at reading other peoples code. Over time, I realized that it's something almost every programmer struggles with on a daily basis. Reading other people's code almost feels like reading a foreign language. Even if you're comfortable with the programming language choice of the writer, you still have to adjust to differing styles and architecture choices. This also assumes that the author wrote consistent and reliable code, which can be hit or miss. This is a really difficult one to overcome. There are a few things I've found helped a LOT.

Reviewing other peoples code will improve your code reading skills immensely. In the past two years, I've reviewed quite a few Github PR's. With each PR, I feel slightly more comfortable reading other peoples code. Github PR's are especially great for these reasons

* Can be practiced anytime, just find an open source project that you feel like you want to contribute to.
* Practice reading in a scoped context (driving feature or bug of PR).
* Attention to detail required, which will force you to evaluate each line.

The second hack which can help you read other peoples code is a bit more unique. It's a technique I came up with, and it's really reduced the amount of time it takes for me to feel comfortable in a foreign codebase. After looking at the style of the code I want to read, I first open up vi and starting writing code in the style used by the project. When you write code in the new style, it will also improve your reading skills. The style will feel less foreign, as you've actually experienced it. Even if I'm just browsing a random project on Github, I'll quickly do this. Try it out.

## You'll Never Write "Perfect" Code

![perfect](https://thepracticaldev.s3.amazonaws.com/i/8y29au7wj8vkgf6ed5kx.jpg)
<center>[Source](https://www.youtube.com/watch?v=WPoQfKQlOjg)</center>

I was a "lone wolf" developer for 4 years before I started working on a team. For most of that time, I just had this assumption that every programmer in the industry wrote perfect code. I figured it was just a matter of time and effort before I also wrote "perfect" code.
It's something I used to feel really anxious about. Once I joined a team, it quickly became clear that no one was writing "perfect" code. But the code going into the system was almost always "perfect", what gives? The answer, code reviews. 

I work with a team of really brilliant engineers. These are some of the most competent, confident programmers money can buy. Every single member of our team (including me) would have a full blown panic-attack if someone ever suggested committing un-reviewed code. Even if you think you're the next Bill Gates, you will make mistakes. I'm not even talking logical mistakes, I'm talking typos, missing characters. Things that your brain tunes out and will never pick up on. Things you need another set of eyes for.

Strive to work with others that are attentive to detail and willing to criticize your work. Hearing criticism is difficult at first, but it's the only consistent way to improve. Do your best to not become defensive during a code review, and never take any comments personally. You're not your code.

When I'm reviewing someone else's code, I just Google search every choice they make and see if it differs from strong popular opinion. Often times, looking at the same problem with a "beginners mind", can catch things the person would have never gone back and looked at.

## Working as a Programmer Doesn't Mean 8 Hours of Programming a Day

This is a very common question, but people never seem to give a clear answer. 

**Very few people are writing code for more than 4 hours a day**

People who disagree with this are either the exception to the rule or work at companies that should treat them better. Programming is a mentally draining, focus intensive task. It's entirely unreasonable to expect anyone to write code for 8 hours a day, 5 days a week. There will be rare cases where you need to meet a deadline or pull a little extra for a stretch, but those are few and far between. When I say "rare", I mean almost never. Do not tolerate a workplace that abuses you and makes you work overtime due to poor planning/under-hiring.

![saturday](https://thepracticaldev.s3.amazonaws.com/i/4c1ixs0f8gqksw2p7tjo.jpg)

For the record, it's not even in your companies best interest for you to be actively programming for 8 hours a day. Your boss might think that's the case, but it's shortsighted and ignores the longterm implications, on productivity and mental health.

Just to be clear, I'm not suggesting that you only work four hours a day. The other four hours are usually best spent:

* Researching, both work related and non-work related topics
* Discussing your work with a colleague
* Helping coworkers who are struggling with their own work
* Planning your future work
* Code Reviews
* Meetings

I also highly recommend taking regular breaks during the day, and exercising (even if only briefly). The benefits of exercise on mental fatigue are well documented. I've personally found that exercise especially helps if I'm having trouble focusing.

Update: [/u/terriblesarcasm suggested that I add what a developer should be doing in the 4 hours they’re not programming](https://old.reddit.com/r/programming/comments/cdi3l0/things_all_developers_should_learn_in_college/). I added a section addressing that.


## Conclusion

These are a few of the things I wish they were teaching at university instead of pure theory. In the process of writing this, I came up with a ton of other items but those will have to come in the next post!