Hi, I am Lars Engel, Senior Software Developer at Sunrise Village. In this blog post I will give some tips on how you can become a better software developer if you really dive deeper the programming languages you are working with.

As a software developer you are most likely used to work with a lot of frameworks and libraries. At InnoGames we use, for example, among others Spring Boot in our Backends written in Java. Writing software using libraries has a lot of benefits but also some drawbacks. This blog post will not go into detail about that topic, as it could be a complete discussion on its own. Nevertheless the reasons to use libraries in the daily business are obvious and include: 

  • Do not try to reinvent the wheel.
  • Libraries simplify the development by providing functionality
  • Using the same library in different products allows better cross team support.

Getting familiar with the used programming languages

One important point when using a library is, however, that you should understand the code you are using.

Understanding the libraries you use…

In Spring, for example, a lot of functionality can be added by using annotations. For instance, you can mark a method or class with the annotation@Transactional to signify that this code should be executed inside of a transaction (see Documentation) that can be e.g. committed or rolled back. This makes transaction management quite easy and enables everyone to quickly add transactions to the code. But what actually happens when adding the annotation to a method? How would a transaction be propagated to another method in the call stack with the same annotation? What side effects could occur when using it? These and more questions should be asked before using an annotation in your code. 

Understanding the library functionality you are using is essential for preventing errors

This example from the Java / Spring World can be adapted to any other programming language and library or framework. Therefore I can only advise anyone to get familiar with a library before using it. Reading the documentation of used functionality is the bare minimum. Downloading the actual code and checking the implementation of a framework enables a developer to completely understand a library or framework to be able to see why things are done a certain way in the implementation. You will know if using a library method produces overhead and you can comprehend if there could be a better way of implementing functionality for your use case.

Challenge yourself to only write native code…

As mentioned in the beginning of this post in the daily business we are using a lot of libraries and frameworks to take over some of the implementation details. In my opinion every developer should, however, be able to implement functionality using only native code of the respective language.

Relying on using a specific library will make you, as a developer, less flexible to adapt to new situations (new projects or companies using different / no libraries, …). What happens for example if you are used to work with a specific library but suddenly it is not maintained any more?

Furthermore, being able to write native code will also increase the base knowhow about the respective language. What datatypes does my language support? How is the memory consumption when using specific datatypes?
Not being able to rely on libraries providing e.g. Algorithm implementations will also require you to get familiar with algorithms or design patterns yourself. How do different sorting algorithms work? How do I implement a Builder Pattern?

Last but not least writing native code will also let you understand what your native language supports and what functionality comes from a framework. Knowing this can be a huge asset when working in a project that uses libraries.

Creating your own library or framework

One further step in becoming a better software developer is starting to write your own library or framework. 

Improve your development knowledge…

A project like creating your own library will touch several components of software development that might not be touched during the usual feature development. Oftentimes we work on already existing products or take implementations as a base for a new product. This means that areas of software development might not be learned in the day-to-day work. By writing your own library from scratch you will definitely have to take architectural decisions and have to think about the application flow of your code. Usually topics like Inversion of Control, Reflection or Abstraction could also be important when writing a library.

Improve your soft skills…

Next to the obvious technical skills that will improve when working on such a project, there are also benefits for your soft skills. A project, like creating a library needs planning. For a successful implementation you will need to create a roadmap, plan tasks, set requirements, etc. Furthermore you will learn to take ownership by being the person responsible for the project and you will learn to work self determined.
Another aspect you will have to deal with is communication. In case you plan to publish your library or framework you will need to communicate with interested stakeholders (e.g. other developers wanting to use your library or product manager interested in using the library). You will learn to answer questions, you might have to justify your implementation choices, or handle / turn down suggestions of improvement ideas.  

Boost your personal development plan and reach the next career goal…

A standard practice to consistently improve is to set a personal development plan (PDP) for a specific timeframe. At InnoGames we set ourselves, together with the respective lead, a new PDP every 6 months. As a software developer usually the goal is to improve your development related skills to eventually be able to reach a new career step. 

A project like the creation of a library can be used to set new goals for your PDP easily. It is possible to add new functionality or to extend your project with each PDP by focussing on areas that fit to your current career situation. If you see for example that you lack specific technical knowledge to reach a new career goal you could focus in your next PDP on that specific topic. In the next appraisal or assessment meeting you can show your supervisor the new gained knowledge by presenting the results of your project.

As shown above you will gain a lot of technical knowledge and also will improve your soft skills with such a project. An additional measure to boost your career is to increase your visibility inside of your company (or even outside) by publishing your results and presenting them to your colleagues. 


In conclusion, I have to say that all the measures mentioned in the sections above will take some extra time. Maybe you will even need to sacrifice some afterwork evenings or weekends. But in my opinion the gained benefits are definitely worth it. Being able to confidently say to understand how a programming language works can only be done by learning the actual language you use. And even if the framework or library you are writing will not be used later in a production environment, the learnings you achieved on the way will stay for ever and will make you a better software developer.

Therefore I hope this article could spark your interest in starting to look under the hood of all the frameworks and libraries that are used in your project.

Lars Engel

Senior Software Developer, Sunrise Village

LinkedIn / TwitterXing 

InnoGames is hiring! Check out open positions and join our awesome international team in Hamburg at the certified Great Place to Work®.