The starting of the year is a good moment to think at the future. How can you grow your career? How can you have a (more) stable job? How can you be more wanted in a competitive market?This article contains 10 technical skills that a programmer can learn and can help grow your profile with your colleagues and managers.
Formula 1 cars have many secrets; the best kept one is the tyres. The reason is simple: no matter how efficient the engine is and how good the pilot, the tyres are the ones that connect the car with the running surface.
Similarly, the keyboard is the way the programmer"s brain connects with code. Your ideas, no matter how good they are, must translate into code as quickly as possible. Touch typing is the skill to write on the keyboard without looking at it. It allows fast typing and focus on problem resolution. Moreover, it allows reducing the time spent writing emails or documentation.
Like any other skill, touch typing can be trained through practice. www.typingstudy.com , www.typingclub.com/typing-qwerty-en.html or play.typeracer.com are websites where you can learn touch typing or compete with friends or co-workers. Using these websites usually turns into a fun activity, because of their competitive nature.
Modern code editors have hundreds of features. Some of them are extremely useful and not used enough. Mastering them allows quick editing, navigation and code modification, even with unknown or poorly structured code. For example:
Many other useful features are documented in cheatsheets available online.
Any code change requires validation. For the programmers who use a compiled language, the validation time depends on the compilation time. It"s never pleasant to wait for a program to compile; plus it"s easy to lose focus in this time.
Java IDEs, like Eclipse or IntelliJ Idea, offer continuous compilation on the expense of CPU and memory. .NET Daemon from RedGate (www.red-gate.com/products/dotnet-development/dotnet-demon) offers the same thing for .NET.
Even without these tools, it is possible to significantly decrease the compilation time of a program, no matter how large it is, through a few techniques:
A feature can be implemented in countless ways. Only a few of them are both correct and easy to extend.
One of the common simplification methods is to use to the maximum what"s already implemented in the technology. Language constructs equally allow simplifying the code.
A counter-intuitive method to master a technology is to try other technology and compare. The simplest way to try another technology is to collaborate with a knowledgeable programmer, either by discussing on existing code or by writing new code using pair programming (see 2).
The main problem developers everywhere face is that they always need to modify existing code. In the beginning of the project, the code is easy and quick to change. As the project advances and more code is written, modifying it becomes challenging. That"s why the application design should be optimized for changeability.
SOLID principles and design patterns have emerged as solutions from the common experience of programmers more than 10 years ago. Any team challenged by code changes should invest time in profoundly understanding and applying them.
Difficult to change code can be transformed into easy to change code through refactoring. Refactoring is an investment in the future; the resulting code "opposes" less resistance and the cost to implement a new feature decreases.
To refactor successfully, a programmer needs two things: knowing and applying the principles of changeable design (see 6) and optimizing the refactoring time.
Here are some secrets of effective refactoring:
As new features are added to an application, the testing time tends to increase. Modularization, adding new testers and automated testing are possible solutions of this problem. Teams that choose automated testing often fall into the trap of complex and difficult to maintain tests. The solution is to structure automated tests using the pyramid of tests.
The pyramid of tests is a structured approach to automated testing through the division of tests in categories:
An effective testing strategy is based on a combination between many unit tests, just enough tests from the other categories and exploration testing to prevent most bugs. This strategy can cover a whole application (if it"s business or life-critical), or just the most risky parts. An architect or CTO can define and see to the implementation of this strategy.
Most programmers work with existing code. It is often older than 2-3 years, sometimes 10+ years. The initial team members are not in the team anymore or can"t answer questions. It is therefore the job of the programmers to understand and change the existing code without introducing new bugs when adding a feature or fixing a bug.
If testing a new feature is easy, validating that nothing else was broken is much more difficult. At the same time, we would like to improve the design to optimize adding new features in the future (see 5). But how to do it, if the existing code is unclear?
Special techniques to understand and modify unclear code have been created in time. Some of them are:
•Golden master: writing automated tests that first store the outputs and on the next executions compare them to the initial ones. They ensure a first safety net against undesired changes, but are just an intermediate step towards unit tests.
•Characterization tests: writing automated tests with the purpose to discover behaviors of existing code. Once a piece of code has been covered with characterization tests, it can be extracted in new classes or methods, as a first step towards design simplification.
•Extract and override: a technique that allows focusing on a small piece of code. It"s composed from extracting a complex piece of code that we don"t yet want to focus on in a method that is then overwritten for testing purpose (a partial mock).
•Exploratory Refactoring: Refactor with the purpose of discovering alternative designs. When refactoring is automated through scripts, you are using the Mikado Method.
Many other techniques exist, most of them described in the book "Working Effectively with Legacy Code" by Michael Feathers and treated in the workshop "Working FAST and Safe with Existing Code" (www.mozaicworks.com/workshops/working-fast-and-safe-with-existing-code) .
Technologies and the software industry change continuously. Programmers have to learn new things all the time, so optimizing learning is very useful.
A few methods exist to learn faster, and some of them are:
For more details, read the article "5 Trick to Amplify Learning" (www.mozaicworks.com/blog/5-tricks-to-amplify-learning/).
The most important thing is to enjoy your work. There will be difficult moments, problems and misunderstandings in any team. It"s important to remember that programming is an amazing job, that you"re working with intelligent people and that we can often ease the lives of our users.
Celebrating team successes, events like "code and beer" or code retreat, working with unknown programmers at community meet-ups are just a few ways to enjoy writing code and to remind yourself how fun it is.
Have Many Accomplishments in 2014!
by Ovidiu Mățan
by Irina Rotaru
by Dan Ionescu
by Roland Szabo
by Tudor Cioară
by Dhyan Or
by Monica Soare
by Marius Iatan