Skip to main content

In the tech industry, the terms “software engineer,” “software developer,” and “software programmer” are thrown around, sometimes interchangeably. What’s the difference? i’ve got some thoughts.

What’s in common

These job titles all have something in common, and that’s working with code. In any position I’ve held with any variant on these titles (granted, I haven’t had a “programmer” title before, but a pair “developer” and a pair “engineer” titles), I worked with code. I built things using code. the items I built differed between these titles and therefore the magnitude of the selections i used to be making was different further.


Programmer could be a loose term. If you rummage around for definitions, you would possibly get something like “a one who programs computers.” Super insightful, thanks dictionary… So what does a programmer actually do. Well, they uh, they program computers. With code. Okay, so to be a programmer we’ve got to understand a way to code. Some people learn coding all by themselves, others from friends or family who get them interested, but I learned in school.

I started my programming career in college. I had no idea the way to code, and no idea about this terrible conundrum around software programming job titles. But I learned like anyone else does. I made a bunch of infinite loops. I made off-by-one mistakes constantly. I learned that the compile cares about every single character. I learned how the syntax mattered, and what “algorithm” meant and about class structures and definitions. And then, I learned to make programs that may actually do something. that’s a strong feeling. Not just employing a computer, but telling it what to try and do and the way to try and do it, so seeing it’s done. it had been intoxicating. Anyway, I learned the way to make programs that may fulfill my assignments and sophistication requirements for my programming classes. That’s the important part: coding to make a functional program.

For the programmer, the program is that the scope. The programmer is concentrated on one problem at a time, and builds individual solutions one at a time. A programmer may need individual programs built to maneuver files around, translate CSV data, clear up cached data, or mass-kill certain processes. The programmer focuses on creating individual solutions to individual problems. But, there’s more to software than simply programs. Programs may be fit together and that they evolve over time to satisfy new requirements or make use of recent tools or the ever-changing “best practice.” So, a programmer is specializing in the building blocks of software systems. Therefore, i think the programmer isn’t specializing in what a developer is, a minimum of in my interpretation of the title (not to offend anyone, you’re all awesome and do cool stuff, and plenty of of you, all nine of you that read this, are likely better programmers, developers, and/or engineers than me).


What differentiates a developer from a programmer? The verb here has changed from “program” to “develop.” Now, I know, you would possibly be thinking, this guy is wicked knowledgeable on all things English. I hope a number of that’s true. But seriously, the action is different. To develop is to assist something grow, or to become more elaborate and sophisticated. While a programmer may create and maintain individual pieces of software, a developer is orchestrating many pieces of software to perform more complex tasks.

Speaking of complex tasks, developers also manage environments — both actual application environments (dev, staging, prod), and development environments (system configs, IDEs, plus libraries and frameworks). I can recall having to determine which software I wanted, and the way I wanted everything configured after I entered my first “software developer” role. This wasn’t much of an option in my college program — you had few options for love or money in terms of operating systems and such within the varsity labs. There’s not much of an environment hierarchy within the school network either. It’s just about what you run locally is what you’ll be able to run. Sure, you’ll setup a server or two on one machine, but you most likely aren’t putting in production-level applications running off your school network account or hardware. So I had to be told this stuff, but I also just had to be told to write down production code. And production-level code comes with new problems.

One of my roles as software developer included maintaining multiple web applications with complex (and truly awful, but we will speak about that another time) codebases. the dimensions had increased. I wasn’t managing the single-file programs and also the code equivalent of chicken-scratch to “just make it work.” Now, I had to know how new features and requirements are changing the form of the software. I had to know the expansion of the plant that’s our codebase. I had to prune it by getting obviate dead code. I had to water it with nutritious unit tests. I had to stay it within the sunlight of “good practices” and with all this, hopefully it blossoms into something beautiful.

It didn’t. There was no blossom. No plant. It died on the proverbial vine. I’ll compose that sometime later. Let’s speak about the last job title during this discussion.


Again, the verb changes. To engineer is to style and build (and maintain). i believe the key word here, because it relates to software jobs, is design. the size of the look has expanded. We aren’t focused on designing an honest algorithm, or designing an object-oriented class. We are designing darn near everything for whatever task we’re trying to induce software to try and do.

Because the dimensions of the look has expanded, the rigor has increased similarly. rather than being expected to put in writing good code with good comments, and good documentation, you’re expected to jot down good design documents considerately for all manner of things and good reasoning for everything. Design documents, for the uninitiated, are a group of proposals for software design, including diagrams, charts, graphs, code samples, best-guesses, caveats, and an oversized smattering of “this is why i’m proposing what i’m.” A design document for a brand new feature during a web application might need sections on API design, introducing new code patterns or a paradigm shift, employing a new framework (ooh, shiny), performance considerations — how long would it not fancy grab all the Foo objects that a user might request and type them, or any number of other considerations.

That’s the thing, there’s more considerations. There’s more rigor in detailing what we are going to do before we know. we’ve to think about the downstream impact of the changes we propose. we’ve got to compile a collection of actions with corresponding supporting arguments, which break down within the sort of hopefully objective reasons. So, we spent lots of your time detailing pages and pages of what we’re visiting do. But who goes to read this? Everyone who must. Or everyone your manager or tech lead thinks has to. Or everyone you think that has to. So reviewers will read your document and make comments and “why don’t you are doing X here?” and “why not follow Y convention here?” and “how come you’re not also rewriting that 10,000 line collection primary pipelines that I don’t want to keep up anymore once you do your thing?”

You’ll be expected to retort, of course, to every comment and piece of feedback, criticism, and questions you get on this thing. Eventually, everyone signs off on this document and says “okay, implement it now.” Then you are doing. Then you transition to software developer and plant a brand new seed and make it blossom beautifully.


If your job title is “software programmer”, you’re probably a decent coder. If your job title is “software developer,” you’re probably a decent coder. If your job title is “software engineer,” you’re probably an honest coder. employment title doesn’t always reflect your ability or perhaps your responsibilities. I’m just rambling on about how I see these titles, and what they’ve meant to me as I’ve traversed my very own career. I learned to program in college. Then, I learned to develop software at my first few jobs; plenty of errors, many whiteboarding and code review comments. After that, it absolutely was onto engineering, learning the formal design processes, broader considerations, and after all design documents.

I hope that something I said here was insightful or even made you’re feeling better about your own career trajectory. Hopefully you found something a bit funny a minimum of once. Let me know if I missed something or if you disagree wholeheartedly.