What it will take to be relevant in the next 5 years?

I wanted to share my personal thoughts on what I think I should master in the next five years and what it will take to be relevant in today's fast changing world of programming.

Some words on object oriented design

Object Oriented Programming was a darn good concept of the day and it will be a huge part of the industry for years to come. The problem with OO is the fact that it is not easy to understand the state of things in an OO program.

I think, Joe Armstrong, creator of Erlang, said something along the lines of: "In OO, if you ask a banana, you might receive a banana with the gorilla and the jungle". When we encapsulate data and behaviour in an object, we have no idea about what is going on there. Of course, one might argue that good OO design might solve this problem. I agree to a certain degree since normally you don't have control over third-party libraries.

Another issue of OO that is being felt across the whole industry it the multicore problem. Traditional threading mechanisms are not a great way to approach the concurrency problem. It is darn easy to make a mistake. You have to worry about the thread safe data structures, race conditions, and locks, mutexes, semaphores and whatnot.

These problems are, of course, solvable. After a fair experience in "the field", you will know all in's and out's of a particular technology and what it will take to make a program thread safe.

The only problem I am having with this is the fact that transient bugs are hard to catch. It's hard to debug a system where you don't know what is flying around where.

Going functional...

I believe the world is gradually going functional. Starting from things like Clojure on JVM, Elixir on BEAM and academical Haskell. These languages bring the sanity of programming back to the developer.

All three of these languages that I mentioned are immutable. That brings a lot of intriguing possibilities to the table. Let's depict these languages one-by-one.

Elixir is built on top of Erlang virtual machine or BEAM. The key benefit of using this language is the underlying actor model and the virtual machine itself. The concurrency is achieved via lightweight processes that are handled by the virtual machine. Elixir also leverages existing Erlang ecosystem and the interop costs nothing. There are also pleasant things like pattern matching, compile time metaprogramming and much, much more. Check it out here: http://elixir-lang.org/

Clojure is an interesting beast. It is built to run on top of host virtual machine and can work on Microsoft's CLR, JVM and JavaScript. This allows to take advantage of existing ecosystems and interop with them. Like Elixir, Clojure is immutable, dynamic language. Clojure has transactional memory, which allows you to work with the concurrency the same way as if you would work with a database. Clojure is really well-designed language and I recommend a talk by Rich Hickey, the creator of the language http://www.infoq.com/presentations/Simple-Made-Easy

One can't talk about Functional languages and not talk about Haskell. It is "The Mother of Dragons" of the functional languages. Haskel brings immutability, pure functional programming and really well-designed type system to the table. What I like about Haskell is the fact that you have to mark "Unsafe" code to be able to do any operations that are not purely functional. The compiler itself, because of the nature of the language, can do insane optimizations in the compile time.
Check out Haskell here: https://www.haskell.org/

Conclusion

The way these languages approach programming is totally different from the way we are used to thinking in OO languages. It takes quite a while just to "get" the concepts and understand basic principles behind them, but it is worth to sow the seeds right now and to reap the benefits in years to come.

Janis Miezitis

Read more posts by this author.

Subscribe to Janis Miezitis personal blog

Get the latest posts delivered right to your inbox.

or subscribe via RSS with Feedly!