No momento, esta página está disponível apenas em inglês.
Hands typing on laptop with binary superimposed

Originally published on June 3, 2014, this post was expanded and updated on January 2, 2019.

It’s an all too common story in many professions: You go to school for years and walk out with a freshly printed diploma. You snag your first job—and immediately, you’re buried under a pile of unwritten rules and day-to-day complexities that no one bothered to warn you about.

Programming jobs are no exception, even with the rise of coding boot camps: those accelerated schools that promise to teach you everything you need to know about coding in a matter of months.

As it turns out, whether you’ve earned a Computer Science degree or a boot camp certificate, odds are you’re still not 100% ready for your first real job writing software. The basic skills listed here—which you may or may not have learned in school—can help you get started doing real work with less hand-holding and fewer mistakes. We’ve divided the list into three categories: technical skills, habits and mindset, and soft skills.

Technical skills

These five technical skills should be part of any beginning developer's toolbox. If you didn’t learn them in school or boot camp, it’s time to get up to speed now:

1. Version control systems

Every graduate of any school should know the basics of using Git or another version-control system to track computer source code—just as she should know how to create programs in languages like Ruby, Python, or Java. Every programmer should know how to create repositories, edit and commit code, and branch and merge effectively as part of a project workflow using Git.

Acquiring this skill is not just a practical issue; having your work backed by a good workflow affects how you write code. Continuous integration (CI) relies on version control. You write code in discrete, more manageable tasks. Without version control, refactoring of code can be dangerous.

Version control systems are ubiquitous within software development teams these days, and a new employee joining a company without understanding the basic mechanics of Git is going to be at a disadvantage. Knowing about version control systems also means that you’ll know better than to work for an organization that doesn’t use one.

For an introduction to Git, check out Pro Git by Scott Chacon, available in print and free online. For a wider survey of version control concepts and systems, see Version Control by Example, by Eric Sink, also available free online.

2. HTML and CSS basics

If you're working in app development these days, chances are you're working in web apps, whether or not they're on the public internet. The ability to create functional HTML documents is an assumed skill—similar to making a Microsoft Word document (or a Google Doc). And these days, working knowledge of cascading style sheets (CSS) goes along with that HTML expertise.

The key knowledge here, besides the mechanics of well-formed HTML documents, is not understanding arcane browser-specific tricks and tags, but rather thinking in terms of semantic document markup and knowing how to separate document structure from presentation.

3. Developer toolkit: IDEs, editors, and CLI tools

A carpenter would never complete an apprenticeship knowing how to use only a hacksaw, so it’s important that computer science programs and coding boot camps graduates know more than Notepad or Pico.

Programming tools exist to manipulate source code and other development resources to make a programmer’s life easier—often much easier. The Unix command line and standard Unix tools like the bash shell, find, grep, and sed should be part of every programmer’s knowledge set. Heck, even programmers using Windows can use these tools starting with Windows 10.

For an introduction to working with the command line, I recommend Brian Hogan’s Small Sharp Software Tools.

4. Regular expressions

Regular expressions constitute a powerful mini-language that programmers can use to find patterns in text strings, in ways that simple string searching can’t match. Unfortunately, regexes (as the term is abbreviated), get a bad rap in the programming world from developers who seem to be afraid of the syntax.

Don't listen to the haters. If part of your program, for example, must ensure that a part number in a database has five letters, a dash, and a digit, then using a regex like /^[A-Z]{5}-\d$/ to validate the pattern is how you're going to do the job. Regular expressions can be hard to read if you're not familiar with them—but you didn't come out of the womb knowing what f = (9/5) * c + 32 meant, either.

5. SQL

The era of storing data in flat files is long gone. Everything goes into and out of a database—and SQL, or Structured Query Language, is the language that’s used to retrieve it.

As someone said to me at a meetup once, "All the SQL I know I learned on the job. Why are databases an elective in computer science programs? What doesn’t use a database?"

SQL is a declarative language, not a procedural language, which means that it requires you to learn a new way to think about solving problems. Every programmer should understand the basics of database normalization and be able to do SELECTs (including basic INNER and OUTER JOINs), INSERTs, UPDATEs and DELETEs.

The process of learning SQL and regular expressions has another huge benefit: It requires you to think in terms of different metaphors. SQL is all about operations on sets of data, not looping and branching the way imperative programming works. Regexes are about finding patterns in text and considering what parts of the data you want to use and transform. Adding new paradigms and different ways of thinking help sharpen a developer’s problem-solving skills.

There are many SQL tutorials online, but SQL Zoo is excellent, and I also like Allen Taylor’s SQL For Dummies. For next steps in your SQL learning, I suggest Stephane Faroult’s The Art of SQL.

Mindsets, habits, and soft skills

Being a competent programmer isn’t just about languages and tools. New programmers need to know more than just specific pieces of software and languages. They also need to understand how to communicate with fellow software developers, how to stand on the shoulders of their forebears, and how to minimize errors in their work. That’s where these soft skills loom large:

6. Clear and effective written communication

Working as a programmer is more than just coding in a programming language. You also have to write release notes for your projects. You write commit messages for version control. You write tickets for bugs in the system. All of these tasks, and many more, require clear and effective English (or some other human language) communication—a skill that computer science programs seldom emphasize.

As more jobs become remote, and more teams connect via email, collaboration platforms like Slack, and ticketing systems, the ability to communicate clearly and effectively in written English becomes even more important.

7. Using libraries and other existing code

New developers typically learn how to solve problems by writing their own code, but a wise developer knows when to leverage existing code to solve common software problems. No developer should waste time trying to write code to extract the host name from a URL, for example, when libraries of proven, debugged, and thoroughly tested code are readily available.

(For a look at some of these common coding tasks, see my post on Seven Things You Should Never Code Yourself.)

8. Defensive programming

Even the best programmers are fallible; much of the world is out of our control, and things continue to have a habit of going wrong one way or another. Defensive programming is about coming to terms with these simple truths.

If things didn’t go wrong, we wouldn’t have to check file opens for success, for example, or assert that customer IDs are valid integers, or even test our code to make sure that it works properly.

Programmers need to grasp that compiler warnings are helpful tools that make life easier—not nuisances to avoid. In fact, wise developers enable as many automated quality checkpoints as they can to find potential problems in their code. Every programmer should also know why every PHP program should start with error_reporting(E_ALL), and why all JavaScript programs should incorporate the “use warnings” directive.

Another important aspect of defensive programming is having a security mindset. In a world where most apps are web-facing, programmers must consider the possibility of input that’s not just unexpected, but actively malicious. SQL injection attacks, for example, are predicated on programs that blindly use untrustworthy outside data.

9. Debugging

All programmers should be able to debug with an interactive debugger or by sprinkling print statements liberally throughout the code. The ability to track down a problem through stepwise refinement is too important to be left for programmers to learn by the seat of their pants.

Notably, the ability to narrow down problems to find root causes goes hand-in-hand with the ability to communicate effectively. Writing an effective bug report requires finding the core problem, but it also demands the ability to communicate clearly so others can understand what you’re talking about.

10. Teamwork

Few programming jobs allow you to work entirely on your own, and even those programmers who do work on their own don't have the benefit of learning from others. In almost all cases, your code must interact with other programmers’ code, and in many cases your code will actually be intermingled with code from others. No matter how talented they may be, programmers who can’t collaborate on projects with others will have drastically reduced or even negative productivity, dramatically lowering their value to their organizations.

Bonus: Working on existing code

In Computer Science school, class assignments are typically a new, greenfield projects. That’s not how it works in the real world. The first thing that happens to new software engineer hires is an assignment to fix ticket #8347 in the bug tracking system. After that, they have to add a small new complementary feature to an existing system with an established codebase. Writing new code to solve new problems will come months later—if you’re lucky.

Here’s one way that schools—whether in a Computer Science degree program or at a programming boot camp—could make assignments more like the real world of software development: After the class does assignment #5, Alice would review Bob’s code as assignment #6, discussing what’s good about it and what could be improved. Then, assignment #7 would be Alice extending the functionality of Bob’s code.

If the original program is fragile or broken, then it falls on Alice to fix it up—and of course, badmouthing Bob or his code is forbidden.

Another way to work on these skills is by contributing to open-source projects. Working in open source involves many of the same skills discussed in this post:

  • Version control
  • Working on remote teams
  • Written communication
  • Release-based projects
  • Taking advantage of existing code
  • Building atop existing code
  • Test-driven development

For ideas on how to get involved with open source, see my post on The Beginner’s Guide To Contributing to Open Source Projects.

Double-bonus: We're all learning as we go!

Think of this last point as a tidbit for a Computer Science commencement speech: New developers need to know that we're all learning as we go, and there's nothing wrong with asking for help. I've seen new software engineers who are embarrassed to look in manuals or on the internet for arcane syntax or specific calling conventions for functions.

Don’t be. As a software developer, your job is to solve problems, not to memorize the sequence of arguments to the substr function. And don’t worry, over time and with enough practice, you'll find that you need to look in the manual less and less.

However, it’s not all about finding answers online and pasting them into your code. Looking up answers to questions on StackOverflow is good as far as it goes, but it’s important that you understand exactly what you’re cutting and pasting into your code. One trick is to avoid direct cut-and-paste operations from online sources. Instead, retype it by hand. This helps ensure that you read every character that you put into your program.

If you're a new developer, whether you’re just getting out of school or making a career change later in life, I hope this post has sparked some ideas and areas for further exploration. If you’re an experienced software engineer, then I hope that this list has reminded you of something important, or that it inspires you to help out junior developers in your organization or in your community.

Finally, I want to recommend two essential books for all software developers: Code Complete, 2nd Edition by Steve McConnell; and The Pragmatic Programmer: From Journeyman to Master, by Andy Hunt and Dave Thomas. Both contain timeless advice about the practice of software construction and belong on every programmer's bookshelf.