If you asked a senior developer the difference between a software engineer and a developer, you’d probably be met with a confused face.
Here’s the technical definition of both:
A software engineer is someone who builds (engineers) software. This software could be desktop programs like Spotify or Photoshop, or mobile and web applications (like Facebook, Twitter, or Gmail). Another term for this is “computer programmer.”
A web developer is a software engineer who only builds web applications.
But, every web developer who is employable is a software engineer. “Software Engineers” don’t have a better salary than “Web Developers,” nor do “Software Engineers” do different work than “Web Developers” on a day-to-day basis, assuming they’re working on web applications.
What makes a web developer a software engineer? Let’s zoom out and talk about three skills all programmers need in order to be in demand.
The Only 3 Skills That Software Engineers (AKA Web Developers) Need To Land a Job
Skill #1: Ability to follow directions.
As a developer, you’ll often use programs or code that was written by other developers. Other developers will often explain in a written format how to use their code. Being able to follow their instructions will give you the ability to use their code.
The most important skill here is attention to detail. Typos and missing letters or punctuation will likely result in code that doesn’t work. The ability to compare instructions with code you’ve typed, and identify small differences are important skills.
Skill #2: Ability to follow patterns.
In web applications, there is one concept that comes up a lot. It’s called CRUD (short for: Create/Read/Update/Destroy). When it comes to database-driven applications, most are built to push data into the database, and pull data out of it.
Regardless of the item you’re pushing into a database (whether it’s a user, a place, a comment, etc.), the pattern of doing so will be the same, even though the code will have slight modifications depending on minor details.
The ability to look at similar code and custom tailor it to the specific case you have is important.
For example, in Ruby on Rails, the following code would put the user-supplied data in a form for places into the Place database table.
Following this pattern, you should be able to figure out how to take the user-supplied data for a comment, and store it in the database.
You’ll notice this line of code is basically the same as the previous line of code with a few changes:
- The first part of both lines of code is the name of the item we’re creating. It’s always capitalized and singular.
- There is a
.createpart that follows.
- Then there is
something_paramswhere “something” is the name of what you’re pushing into the database. It is always lowercase.
Looking at things you’ve coded in the past, and recognizing the patterns and following them is a skill that is difficult initially, but eventually becomes easier. As a programmer, this is a skill that becomes second nature!
Here’s why the ability to follow patterns is important:
There are a number of problems that you will face frequently as a web developer. These problems are generally solved by a framework. These frameworks (whether you use Rails, Express, Pylons, Django) will allow you to solve most common problems in a single line (like we showed above).
This means that all you need to learn is how to use the framework– basically, learn what 1-line-of-code commands do– and the framework will do the rest. This is good because you should be spending your time building out awesome applications, not reinventing the wheel!
Skill #3: Ability to write algorithms.
There are many problems that are not common enough to have their own 1-line solution. Instead, the solution will require multiple lines of code.
The ability to program involves figuring out how to break a problem down into small, bite-sized chunks (individual lines of code) that you can then command a computer to solve for you. Here’s a simple example:
- For the text, “Bob likes dogs,” figure out how to reverse the sentence so it produces the text, “dogs likes Bob.”
The above problem isn’t something that is very commonly done, so you don’t have a single, 1-line solution to use. You’ll need to use the full expressiveness of the programming language to solve the problem. Breaking a program apart into steps that a programming language supports is known as “writing an algorithm.”
Computers– like the human brain– have the ability to solve problems, but they solve problems in a different way. Computers need detailed, unambiguous instructions to solve the problem at hand. The key to being a programmer is the ability to take vague, ambiguous instructions (like the above) and convert them into steps a computer can do. For the above problem, the steps would be:
- Take the initial sentence, “Bob likes dogs” and split it by the spaces in the sentence and put it into a list: [“Bob”, “likes”, “dogs”].
- Lists can be reversed, so reverse the list to become: [“dogs”, “likes”, “Bob”].
- Then, the list can be recombined with a space between each element to produce the new sentence, “dogs likes Bob.”
The above steps can be converted into unambiguous steps that a computer can perform for us. Here’s a solution in ruby. (If you’re finding this confusing, check out our free Intro Course that explains all of the concepts we use in the code below).
Although this example is a bit contrived (you probably won’t find yourself facing this problem in the real world), the skill of transforming data from one format to another is used ALL THE TIME in programming.
This means that in the quest to learning to be a capable programmer, you will need to get good at converting vague instructions into programs a computer can execute. Most successful programmers build up this skill set by solving increasingly difficult kata (or coding challenges).
You’re not a capable programmer until you honestly believe the following:
If I as a human understand how to manually solve a problem, I am confident I can program a computer to solve the same problem. It may take many hours and a lot of research on Google, but I am confident that if I understand it, I can code it.
In the real world, the problems you face won’t be solvable with a single line of code, so becoming a practitioner of the actual programming language and being able to write algorithms is important. Knowing how to break vague problems into multiple individual steps that a computer can solve is the most important skill you can acquire.
Does Computer Science fit into this?
You might be wondering how Computer Science (CS) fits into this view of the world. CS matters, and there are two important ways that CS topics come into play.
Reason #1 CS matters: The practical parts are useful.
For a concrete example, let’s talk about Twitter. On Twitter, people can tweet, and then other people can retweet their tweet. Throughout all of this, Twitter keeps track of where each tweet comes from. Take the following scenario:
- William Shatner tweets something out.
- Then, Justin Bieber retweets William Shatner’s tweet.
- And then, I retweet Justin Bieber’s retweet.
- Then, Kevin Bacon retweets William Shatner’s initial tweet.
To keep track of where the retweet came from, you need to use a concept that comes up in Computer Science: trees.
Here’s how you could visually represent the events that transpired:
The higher in the tree an element is, the closer it is to the original source of the tweet. With CS, we can convert diagrams like this into code, and using the code, we can run searching algorithms to find certain nodes (called tree traversal). Without an understanding of the science of trees and how to use them, there will be problems that you as a developer will be unable to solve.
By understanding CS principles, you have a big advantage over a programmer who doesn’t because you will know the “correct way” to deal with data that has properties similar to this.
This isn’t unique to Twitter. In most web applications, nuggets of CS can guide you in solving complex, real-world problems.
Reason #2 CS matters: It can help you write code that is faster.
Two different computer programs that have the same number of lines of code can have drastically different speeds of execution. Computer Science gives you the tools you need to analyze code and know how to make your code perform faster. This is done through a concept known as Big O Notation.
Understanding the theory behind what makes programs faster or slower will allow you to craft faster programs than the next programmer.
Your abilities to write algorithms will be the number one factor to your success as a programmer.
The technical interview process is largely a test of your skills in writing algorithms. These often involve the CS topics that are relevant on the job.
Yet, many coding bootcamps only teach the first two skills we mentioned, ignoring the third and by far most important skill.
Without the ability to “program,” or write algorithms, you won’t be ready for a job as any type of a developer. This isn’t limited to certain types of jobs. This is important to any job as any type of developer.
Learning this skill is one of the most important steps you will take on your journey to becoming a full-time developer.
Why most coding bootcamps don’t teach the only thing that matters.
First – it’s hard. It’s difficult to teach someone how to solve arbitrary problems.
Second – it pushes students outside their comfort zone. Learning how to follow instructions and patterns is a lot easier than learning how to write complex algorithms with advanced CS properties.
These problems can take multiple hours to really “click” because it’s advanced stuff.
Third – it requires instructors to be well-versed. Because many coding bootcamps employ their students as instructors, they often lack the real-world experience of using CS constructs outside an academic setting.
But, the good coding bootcamps do teach these topics!
Don’t believe the hype that no coding bootcamps teach these topics. It’s just not true.
Coding bootcamps like Hack Reactor, MakerSquare, App Academy (and obviously our coding bootcamp at the Firehose Project) teach these skills because they are so important. Without these skills, our students wouldn’t be able to navigate the technical interview process and actually get a job offer.
We’ve been teaching these topics since the very first students went through our program.
This means the best coding bootcamps out there are the ones who garnered years of experience in teaching these topics, while other bootcamps were busy pretending they weren’t important.
What do you think matters most?