Created by
Saturday, August 6, 2016

I would like to share my two pence on some of the greatest tips i have learned from great programmers and in turn pass that wisdom on. I have been part of many lengthy developer discussions and read countless articles that both contribute towards what i think a stellar programmer is. Most of which i go through below is based on personal experiences i have had. That combine with mistakes i have made and what i have learned from them.

  • Know your tools. Becoming familiar with your IDE and your environments tools can massively improve your performance in delivering quality content. Keep up to date with the latest tools hitting the market and investigate how they can not just “make life easier” but how they can improve your skill as a programmer. Knowing your tools can be boiled down to even the OS you are on. Know it from a developer's perspective. Don't jump straight into linux thinking it just looks different.
  • Understand OOP and SOLID principles.  As a general rule of thumb you should really be extensively familiar with Object Orientated principles and practises. Moreover mastering OOP requires in depth knowledge of SOLID and SOLID design patterns. Take time and work through each of the SOLID principles and apply them to your work.
  • Be Polyglot. Dont settle on calling yourself a .NET or Java developer (among others). Great developers don’t pick and stick. This doesn't mean you need to start tackling each language and mastering it individually. Take a small task that you may usually do in C# and instead do it in Python/Scala. The more you think in multiple languages the more you will master the art of programming as a whole. Don't say that you don’t know a language, instead say you are learning and working more with it.
  • Write code as if writing a novel.  Your code will be read at one stage or another. Whether you are working on a small single application or contributing to a larger project always write your code under the assumption that another developer will be reading and understanding it in the future. You may understand what is happening but will the developer after you?
  • Use Keyboard Shortcuts. Try to use your mouse as little as possible. Learn the common operations used when developing and instead of pointing and clicking use the keyboard shortcut. After time you will find that all these shortcuts dramatically cut down time and become second nature. Plus it looks cool when others are watching you.
  • Reuse. Aim to reuse as much as possible. If a piece of code is doing what it should be doing then reuse it. If it is not as abstract as you would like then extend on it and move forward. Don’t waste time trying to resolve a problem. Spend time instead understanding what is already there.
  • Learn from others. Without question one of the best ways you could learn to master programming is by studying others. Learn more by working with a reputable open source project. Study the in’s and out’s of how those developers did what they did. Even try and improve on it and understand not how but why. You should not only be thinking about learning from other but also teaching others. Share what you have learned with people less familiar with your skill set. Doing this will improve your confidence in this skill set and it will also enhance your ability to communicate.
  • Git. Git is probably one of the most useful tools you could use in producing software. I use git on my own projects even though there are no other developers working on it! Using Git in a team environment is a lifesaver when it comes to build and release. Commit your code regularly and in small chunks. Break everything up and section things out as you develop.
  • Don’t know it all. There is nothing worse than a developer who has built something and then insists that he or she is the only one that can build further on it and use it. Share your knowledge on everything you do. Sharing with others will open up constructive criticism on things you may not have thought to apply. Both you and your fellow developers will learn from each other. Learning from others is one of the most valuable things you can do.
  • A little something on the side. Don’t limit all your programming time to your paid 9-5 job. Allocate a certain amount of time before or after work hours to constantly be building upon yourself. If you don't specifically have a project you are working on you can find a topic your are less familiar with and start putting it into practise.
  • TDD. Test driven development and Unit Testing are not only paramount in ensuring quality systems but really do improve your work as you progress. Don't rely on others code review (everybody has different opinions) or QA (Its plain not working) to notice when something goes wrong. Breaking either your software or somebody else legacy code is a great way of formulating how it works. Unit testing is also very valuable in documenting your code. Well written unit tests would be the first place another developer should look to understand what a method is supposed to be doing.
  • Structure your projects. Always create with clear and concise structure in mind. Keep all your CSS and JS relatable and in a smart location. Break up partials and classes into where they should belong. Keep things ordered and structured correctly. It not only looks neater but helps out others when they want to add onto your existing style or functions.
  • Don't take on bullshit. Many times i have seen someone with a great idea or some business with a brilliant plan to grow. When these ideas or plans don't quite work out the way the stakeholder had intended they usually turn to the developer and blame them. Unless you are financially invested don't get emotionally invested. If something didn't work out the way it was supposed to don't blame yourself. If you are a master developer then you will have done nothing but your best.
  • Simplicity and Complexity. Keep things a simple as possible. Don't try to reinvent the wheel. At times things will need to get complex. Don't let that stop you from breaking things up. If things need to be complex document it out and comment the code. Let others know why this is they way it is and how to backtrack if requirements change.
  • We are expensive. Developers hours are valuable. Sometimes you get your flow and a lot of times you won't. Do what you think will help. Take an extended lunch. Work somewhere quieter and with less distraction. Find a cool new spotify playlist online. Freshen up on caffeine. Do whatever it takes to get yourself back on track. Ultimately don't waste hours when things are not going as they should. It is beneficial to nobody.
  • Learn your environments. Make sure you are familiar with your local, staging, and production environments. These can change dramatically and can cause profound problems in the long run.
  • Don't always inherit. Inheritance hampers OO over time. With inheritance you don't always get reusability and testability of code. Focus more on interfaces. Dependency injection (SOLID) is a great practise to conform to.
  • Time estimation is really hard. It is extremely difficult to dedicate time to a certain task or objective. Most of the people that will be using/paying for your work will not fully grasp what it is you are doing. Everyone wants to hear cheaper and faster. Be sure to allocate yourself realistic times for tasks. You are not a bad programmer if you say it will take you 3 days when 2 is expected. Explain yourself.
  • Data Structures and Algorithms. Understand basic data structures (binary search trees, hash tables), data types (stack, queues) and algorithms (quicksort, mergesort, heapsort). Take time to learn and practise what you don't fully grasp. Understanding and proving algorithms is highly rewarding and increases critical thinking.
  • Know Computer Science. Computer science and programming are not the same thing. Be sure you understand the basis of computer science. Understanding it will help you think about what is going on under the hood when you are programming.
  • Parallel Programming. Learn the core concepts and basis behind parallel programming.
  • Understand good UX. You may be a back-end/database guru and design quality stable systems. All of that means nothing if the client can't use it. Know how to create something simple and original to the front end user. It can get as complex as necessary in the back end but if it is easy to use people will like it and continue using it. Develop for dummies.
  • Keep up to date. Always keep an eye on sites like HackerNews and other developer new sites. You don't have to take everything that comes to you as the next best amazing thing but it's good to know trends in technologies and how they move. Reading and keeping informed will remind you in the future of some problem you are trying to resolve and that some article you read months before tackled that using a certain something or a certain technique.   


1 2 3 4 5




1 comment
Saturday, August 6, 2016

Nice summary. I have to say i completely agree it it all! This is very OOP centered though.