I released the intermediate package of my Test With Spring course. Take a look at the course >>

The Way of the Hipster

Everyone has heard about hipster developers. These are the guys and gals who are working in startups and doing cool things.

They are not driven by money. They are driven by the will to make the world a better place for all of us.

They use cool technologies. They are agile. They are lean.

You must be wondering how you can become one of them. Let me tell you a secret:

It all starts from selecting the right technologies.

Technology Evaluation Guide for Hipster Developers

If you want to become a hipster developer, you have to select your technologies by following these rules:

Rule One: If It Is Not on Hacker News, It Is Not Cool

If the technology is not frequently found from the front page of Hacker News, it is boring. You want to be cool and using boring technologies doesn’t make you cool. It makes you look boring like those enterprise developers. Poor bastards.

Rule Two: You Want to Have the Latest Toys

If the technology is mature (a stable version has been released), you should not use it because it is not new and exciting. You want to be an early adopter because using new technologies is fun and it makes you look cool. You don’t want to be known as the guy (or gal) who uses yesterday’s tech. You want to have the latest toys.

Who cares if you have to rewrite your application because you notice that the author has abandoned his creation and moved on. That is part of the game. That is what hipsters do.

However, if articles about this technology are often found from the front page of Hacker News, you can consider using it. You will not look as cool as the early adopters but you will not look boring either. This can make you look professional.

On the other hand, who wants to look professional? That is the opposite of cool.

Rule Three: Functional Programming Is Fun

Functional programming is cool, and object oriented programming is boring. You must use functional programming language because everyone knows that object oriented programming does not help you to solve real world problems. Only stupid developers use it, and you don’t want to look stupid. You want to look cool.

Besides, if you use functional programming language, you can do cool things with a single line of code. Who cares that no other human can read or understand your code. A true hipster knows that code is written for computers to read.

Rule Four: NoSQL Solves All Problems

NoSQL databases are superior to relational databases. Database schemas sucks because they force you to specify the structure of your data before you can store it. Also, relational databases force you to write custom translation code or use ORM (which all suck by the way). This is not fun.

Enterprise developers claim that relational databases are better because they support ACID transactions. Don’t believe this bullshit. Everyone knows that ACID transactions are not really ACID.

The biggest problem of relational databases (besides being boring) is that they DO NOT SCALE.

NoSQL databases are cool because you can just shove anything in and read it too. You don’t need to create schemas or write any boilerplate code. The best part of NoSQL databases is that they SCALE LIKE A KING.

If you want to be the coolest kid on the block, you must use a NoSQL database in your every project. Who knows, one of those projects might be the next Facebook and you must be prepared for it.

Rule Five: True Hipsters DO NOT USE JAVA

Java is a verbose programming language which doesn’t support functional programming. Even the simplest operations require that you write a lot of boilerplate code. Do you really want to do this when you can use a functional programming language to write one liners which make you look smart in the eyes of your peers?

Java is a unfashioned dinosaur and it is used by clueless developers. You don’t want to be associated with these guys. You want to be the coolest kid of the block. Remember?

Wait. You still have one more lesson to learn.

Only One Rule Matters

The most important rule of the way of the hipster is:

You shall not look boring.

You want to look cool. You want to be an early adopter. You want to have fun. If you write a blog, you want that your blog post hits the front page of Hacker News.

Don’t worry. If you follow the rules given in this blog post, you have a chance to be called…

A rock star developer.

P.S. Don’t worry about the customer. You can rewrite any application in a couple of weeks. Being wrong is not a big deal. After all, you are not burning your own money. Right?

About the Author

Petri Kainulainen is passionate about software development and continuous improvement. He is specialized in software development with the Spring Framework and is the author of Spring Data book.

About Petri Kainulainen →

17 comments… add one
  • The post is very interesting. I have read same thing on other blogs that Functional Programming is cool than OOP and NoSQL databases should be used instead of RDBMS.
    Obviously we should learn and use this technologies in our side projects because there is no excuse that we use OOP(Java) and RDBMS(MySQL, SQL Server) at our workplace.

    Reply
    • If you are using uncool technologies in your side project, you should not tell anyone about it. If you get caught, your reputation as a cool hipster developer is gone!

      Reply
  • It would be nice if you do posts on:
    i) scenario based differences between NoSQL and RDBMS.
    ii) differences between Functional Programming and OOP.
    You can provide links if you already have posts related to these.

    Reply
    • I have not written about these topics yet. I might do that in the future. In the meantime, if you are are interested about NoSQL, check out these resources:

      • NoSQL Distilled by Martin Fowler. This is a really good book. It does not go too deep to the details but if you want to get an introduction to NoSQL, you should read this book.
      • myNoSQL is a good to place to start if you want to know what is happening in the NoSQL world.

      I must confess that I am not a functional programming expert (Damn. I will never be called a rock star developer now). That being said, I think that the biggest difference is this:

      “OO makes code understandable by encapsulating moving parts. FP makes code understandable by minimizing moving parts.”Michael Feathers

      Reply
  • In as much as I am familiar with the topics of your post, I agree. You choose to make your point using a very heavy handed, and obvious form of sarcasm. Because I see the described behaviors in younger developers too, much of what you say rings true. However, it might also sound a bit overly defensive of older technologies (e.g. Java). While I totally agree that there are droves of folks flocking to the newer things that get lots of press (FP is a good example), I’m not sure the motivation is necessarily simply the desire to look hip, and not boring. Developers are often limited in their technology choices by what they can deliver quickest to the business. The product owner rarely cares about things like long term maintainability or testability or code coverage. Capitalism’s insatiable need to produce it cheaper and faster always trumps quality. Although we are taught so many practices to improve code quality, that will almost always be in conflict with the need to get a product to market. Unfortunately quality is not as sexy or cool as a projected ROI.

    Reply
    • I thought that it would be clear to anyone who reads this post that it is a joke (even though it has some truth in it). I promise that I will make fun of “enterprise developers” as well. I am just waiting for a inspiration to do so.

      About your second point (cheaper and faster always trumps quality):

      Using “modern” languages because of the fast development speed does not mean that the code is crap. It just looks different than the code written in “traditional and verbose” programming languages.

      I think that a product owner might do a right thing when he does not care about quality. Let’s think about the following situations:

      • The product owner works in a startup which hasn’t found its product/market fit yet.
      • The product owner works in a established company and his product has an estimated lifespan of 10 years.

      These two product owners are in a completely different situation.

      The first one (startup) has to maximize the amount of validated learning. In this situation, it might be wise to create a MVP as fast as possible. However, when the product/market fit is found, the technical debt must be paid, or the product team will run into problems later on when it is no longer possible to add new features to the product or maintain the existing features.

      The second one (10 years lifespan) should pay attention to maintainability because maintenance consumes 40-80 percent of software costs. If he does not do so, he should be fired immediately. Obviously, this is not going to happen so I recommend that developers working for this guy should find another job.

      Reply
  • Very nice post. I like all highlighted items. And I’m boring

    Reply
  • Love this post and the sarcasm! There is a lot of truth here though, so many developers flock to use the “flavor of the day” without caring about how that code will be maintained by other team members once they have moved on to the next “big” thing. Use Node.js and Express. Wait no, don’t use Express, that is so yesterday. Use Koa instead…What? wait – You use Java? hell no, use Scala, it makes you look smart…. You get the idea. The on the other side of the spectrum you have the folks who don’t want to try anything new. Dude, you should just write assembly like a real man.

    Reply
    • Thank you :)

      Reply
  • Don’t forget that true hipsters use Macs for development, and will look at you like your an idiot if you say you prefer Windows for development.

    I personally hate OSX for development, but I am forced to use it, making me feel like a crippled 70 year old because the keyboard shortcuts are utter crap.

    p.s. If you don’t believe me, try doing a multiline edit in IntelliJ/Android Studio without changing the binding.

    p.s.p.s. never ask for a mouse, true hipster developers use touchpads and write code in coffee shops.

    Reply
    • Hey,

      I use Mac (and I love it). However, I wouldn’t force anyone else to use a Mac. That is lame.

      Reply
    • Haha so true

      Reply
  • Though I admit I like functional programming with RxJava and Retrolambda, it is quite nice indeed…

    Reply
  • Or one could also do @Annotation Driven Development?

    Reply

Leave a Comment