Software development spans a wide gamut of technologies (e.g. C, Java, and Ruby) and environments (e.g. embedded, desktop, enterprise, web, computing infrastructure, and scientific). Despite all the variation, I believe there are core software development skills that you must possess in order to be an effective developer across most, if not all, of these different scenarios.
More specifically, I believe that your level of ability as a software developer is in large part determined by your mastery of these core skills. Intermediate-level developers should have used all of these core skills and be competent in most of them. More junior developers will likely have gaps where they lack familiarity with some of these core skills and need to increase their competency with the others. Senior developers should have achieved mastery of most of these skills, be competent in using the remainder, and should be able to coach less experienced developers in the use of these core skills.
These core skills can be used both as an evaluation tool and as a professional development guide. Obviously these skills should be assessed in job interviews, but I also find it beneficial to assess developers joining the team, especially the more junior, and assign tasks and provide training opportunities based on this assessment.
The core skills needed by all software developers are:
| Core Skill | Description |
|---|---|
| Read Code | The ability to understand an existing code base in order to analyze its behavior and make fixes or enhancements to it. |
| Write Code | This does not include any significant amount of design – just the basics of coding. An example is being able to write a method given the desired behavior (inputs, outputs, pre-conditions and post-conditions). |
| Design Software | The ability to determine what code is necessary to achieve some specified functionality, particularly the higher-level structure or organization of the code. |
| Awareness of the Software Development Life Cycle | This is an awareness of the 'big picture' of software development beyond just writing code - how the other life cycle stages (requirements, design, testing, and maintenance) impact coding and vice-versa. This includes an understanding of the types of methodologies (e.g. Agile or Waterfall) that can be used to progress through this cycle. |
| Use of Libraries and Frameworks | This skill could also be called "Reuse Existing Code". This skill includes the ability to search for and evaluate libraries and frameworks based on how effectively they meet your needs and the ability to integrate the chosen package into the software you are writing. |
| Debugging | The ability to analyze the behavior of code to diagnose a problem and find the underlying cause. This includes but is not limited to using a debugger. |
| Use of Integrated Development Environments | The ability to effectively use modern IDEs and an understanding of their strengths and weaknesses. |
| Use of Version Control | This skill includes basic use of a version control tool as well as a general understanding of software configuration management. |
| Automated Unit Testing | This is the ability to unit test code by writing automated tests. |
| Refactoring | The ability to revise existing code without impacting its functional behavior. |
| Use of Build Automation | This goes beyond simply writing a build script to include other related automation like continuous integration, automated deployments, and static code analysis tools. |
I have deliberately excluded skills that are not specifically about software development. Some of these general skills are very important to software developers (as well as other professions) and are necessary in order to excel as a developer. Examples of such skills include the ability to communicate verbally and in writing, the ability to work well with others in a team setting, self-discipline, and personal organization.
I expect this list to be contentious. I may have missed a few skills you feel are core or may have included skills that you feel do not belong. Let me know via a comment below what skills you feel should or should not be core.
Update: I revised the description of the skill "Debugging" based on Jacob's comment below.
If you find this article helpful, please make a donation.
The only thing I would disagree with is that I think the skill of debugging (which is certainly core) need not have anything to do with using a debugger. Debugging is the skill of quickly searching out and fixing bugs — the most important part of that skill is being able to rapidly isolate (based on the context and the bug description) what component is causing the bug. The debugger can be a useful tool but a senior developer should not be dependent on it. Just my opinion of course.
I’d also make a broader argument that in many cases what makes a senior developer is not skill but habit — sure, it’s important to know how to write unit tests, but it’s far more important to _actually do it_, for every unit that makes sense to test. Similarly, refactoring is not simply an ability but a habit; the tendency to always leave code better than you found it. You can’t have (and shouldn’t have) the habit without the ability, but the ability by itself doesn’t help much.
Great points, Jacob. I’m going to change the definition of debugging in my article as a result. I particularly like your point about habit being key, although I prefer the term disciplined.
Excellent comments Basil Vandegriend. I’m a Computer Science student in my 2nd year and I found your comments very useful.