Marking Arts Developer Ranking

Original author: Lorenzo Pasqualis
  • Transfer

How do they call developers

In my blog, I use the terms “programmer”, “coder”, “developer” and “engineer” interchangeably to avoid tautology. Nevertheless, I believe that there are some differences between these words and other similar ones.

In this article we will discuss a set of typical nouns for the person who writes the code. I will give my interpretation of how these terms relate to the level of skill.

Interpretation of meanings

The definitions presented here are not official. I do not know any formal definitions or accepted standard. However, many people have a strong opinion on this issue. My understanding of each term is based on 30 years of experience in the software industry, but I am absolutely prepared for others to disagree with my interpretation.

I do not want to argue or persuade people with a different opinion. In general, it is hardly possible here to speak of a right or wrong opinion. However, if you have not yet formed a position on this issue, I hope that this guide will bring some clarity.

Trilateral approach

For clarity, each term will receive three characteristics:

1. Skill level

The description of the skill level for this term, in my interpretation.

2. Parallel with martial arts ranks

Analogy with the ranks of martial arts. In particular, we compare the technical level of skills with the colors of the belts of martial arts masters.

3. Sample code

An example of how a person of this level should approach a simple programmer task. The definition here is trivial and was not intended as a realistic example. The goal is to compare and discuss skill levels. The simplicity of the example is chosen to suit a specialist of any level. Here is the problem we will consider:

Calculate the sum of integers

Please play along with me and present this task as an intermediate one for a much more difficult one. In our fictional universe, a task requires serious thought and has many potential solutions and approaches. Imagine that this is the central module of the system you want to scale.

I will use Ruby for trivial implementation examples. The code is pretty simple: it’s understandable, even if you don’t know Ruby.

3. List

Discussed nouns:

  • Novice
  • Coder
  • (Hacker)
  • Programmer
  • Researcher (computer scientist)
  • Software developer
  • Software engineer
  • Software architect

So, let's begin.

Martial arts belts

When I lived in Italy in my youth - about 20 kilograms ago - then I practiced judo and kung-fu for several years. Then I learned that in many martial arts the level of skill corresponds to the color of the belt. Usually the color changes from white to black, where the level of experience corresponds to the darkness of the belt.

The newcomer wears a white belt because he has no experience. White color means "new and clean." As you workout, the belt darkens, showing progress. Color personifies dirt accumulated with hard work and sweat. A martial arts master with many years of experience eventually reaches a black belt, which means a high level of knowledge and skills.

Traditionally, the belts were only black or white. In recent decades, more colors have appeared. Today, different martial arts schools use different colors. The scheme depends on the style, school and country.

Why are we talking about martial arts?

The colors of the belts are used to draw a parallel between the skills of creating software and the skills of a master of martial arts. To do this, take the color scheme commonly used in Europe: white, yellow, orange, green, blue, brown and black.

The following table shows the developer levels that I talked about. For each, the color of the belt and the position usually given to a specialist of this level is shown:

Professional levelMartial arts level (belt color)Sample post
HackerStreet fighter (without belt)
CoderYellowJunior Developer (Jr.Dev)
ProgrammerOrangeSoftware developer
Researcher (Computer Scientist)GreenSoftware Developer (Software Developer)
Software developerBlueSenior Software Developer (Sr. Software Dev)
Software Engineer (Software Engineer)BrownLead Developer (Principal Dev)
Software ArchitectThe blackSoftware Architect

The level of engineering skills is related to technical skills and teamwork skills. The job title is an example of how a person at this level is called in the industry (it strongly depends on the company and the region).

Beginner: White Belt

Something needs to be started, and usually this is the “no experience at all” level. A newcomer to software development is someone who has just become familiar with programming and is in the early stages of learning. Newbies are still unable to program confidently and do not understand simple programs without checking with books, textbooks or asking an experienced partner for advice.

Beginners are able to write working code, but often do not understand the details of why this code works. They spend a lot of time searching for code fragments on StackOverflow or similar sites and combining these fragments until something works.

Powerful tools are not that reliable skills.

To confuse even more, many “modern” languages ​​and frameworks allow anyone to generate structure and some implementations of complex programs without understanding what is happening behind the scenes. For example, starting a simple Ruby on Rails application and receiving HTTP requests can be organized using several commands from the command line.

Here's how it is done under * nix: Done! This is enough for the server to respond to HTTP requests from the browser. If you compare it with martial arts, it’s like to appear on tatami in armor and with weapons. Armor will allow you to live a little longer, and you can win a fight with a weapon. But such a victory does not make you a skilled martial artist. These tools simply allow you to do something complex without traditional training and effort.

$ gem install rails

$ rails new website

$ cd website
$ bin/rails server

Do not misunderstand me. Tools like Ruby on Rails allow you to get the job done quickly and they are great. In fact, I consider it fantastic to reduce the time to write the initial standard code. This is a great start to the project, but here only a white belt is enough.

The real fight starts where the tutorial ends, where the tools cannot automatically generate the application you need. To move on, you need to become a coder.


If a beginner wants to write a program that summarizes a set of numbers using Ruby, he can google the question and find such a page . This is the first result in the issuance of Google at the time of this writing. On the StackOverflow page, the most unfilled answer with 524 votes:

array.inject(0){|sum,x| sum + x }

Of course it works. Here is an example:

$ irb
2.4.2 :001 > array=[1,2,3]
 => [1, 2, 3] 
2.4.2 :002 > array.inject (0){|sum, x| sum + x }
 => 6

This may work for a beginner, but he does not understand the features of this code. How much does he read? How fast is it compared to other options? Is it easy to maintain? Why does it work? What exactly will happen when you run this line? How much CPU time is used? Are the variables sum and x defined after the execution of this line?

A novice Ruby developer does not know the answers to most of these questions.

Coder: yellow belt

A coder can, without help, gather many lines of computer code to solve simple problems. The result will not be very beautiful, but the coder understands why the program works, and he successfully performs the task.

The first necessary step

I called my blog CoderHood, because everyone who makes a living programming, at some point has reached the level of a coder. The word Coderhood reflects the life of a developer in the technology world, starting with the first yellow belt.

The main difference between a novice and a coder is that the coder is able to write code and understand it. They may not understand in detail what happens behind the scenes, but he knows why he wrote just such code.

In the industry, a coder is usually assigned a position like a “junior developer” (jr. Developer) or trainee (developer in training).


I think that the "Ruby-coder" will be able to come up with most of the following methods for calculating the sum of an array of integers and understand the difference between them:

$ irb
2.4.2 :001 > array=[1,2,3]
 => [1,2,3]
2.4.2 :002 > array.inject (0){|sum, x| sum + x }
 => 62.4.2 :003 > sum=0;array.each { |x| sum+= x }
 => 62.4.2 :004 > array. sum
 => 62.4.2 :005 > array.inject(0, :+)
 => 62.4.2 :006 > array.reduce(0, :+)
 => 62.4.2 :007 > eval array.join '+'
 => 6

If you are interested, some of these methods are terrible, but they work.

Hacker: jeans without a belt

I included the “hacker” because I was asked to do so. But he is not very well suited for our discussion.

Not the main skill

I do not think that “hacking” is a necessary skill in the development of a software developer. This experience is useful to learn how to test and protect software applications and systems, but I don’t see a description of the overall “skill level” here. I would classify this as a kind of realm, not a level of technical mastery. In fact, the skill level of a hacker can be any. Some of them are amazing, while others are not .

Since hacking is not a necessary step in the development of a developer, by my analogy, a hacker does not have a traditional belt. They look more like street fighters wearing jeans.

Some of them are evil goons, others try to survive, and still others are good guys who protect the rest, but most are somewhere in the middle.

Many types of "hackers"

There are many types of hackers. Some can program, others do not. The meaning of the word depends on the context and on who uses it. Some common definitions are:

  1. Computer expert who adheres to the subculture of technology and programming.
  2. A person who could compromise computer security from malicious (black-hat) or research (white-hat) targets.
  3. A developer who does the job in the fastest and dirtiest way.
  4. A person who studies, experiments, or investigates telecommunications systems, equipment, and systems connected to telephone networks. Such hackers are also called phreakers.
  5. A qualified engineer who works very close to the hardware to get better control of the system for a good cause (i.e., to squeeze more performance out of the equipment) or for malicious purposes (i.e., to use security holes and find a way to bypass the operating system protection systems).

Some examples

Type 3

A type 3 hacker can choose this option of summing an array of integers:

$ irb
2.4.2: 001> 'echo "1 2 3" / bc'.to_i
=> 6

The method works, at least on some systems, but it is ... a full hack. So do unqualified hackers who can program. They solve questions in dubious ways, usually by executing unreadable command line commands, until they somehow get the desired result.

Type 5

Type 5 hackers operate at a very low level. Such skills are not easy to acquire and they can be very valuable if you are trying to customize software protection or create extremely high-performance applications. I have never been a “hacker”, but I programmed at a low level (C and assembler) and still, in my heart, I consider myself a specialist in low-level programming.

Hackers of the 5th type can be fantastic street fighters, with insane skills that will lose the nose to many professional programmers on some specialized tasks. Such "hackers" could sum up an array of integers using an assembler like this .

Programmer: orange belt

The programmer can write functioning applications, understands the basic algorithms and knows the basics of computer science. It can make the program work even if it is not very scalable and supported in the long run. As a rule, the programmer works well alone. Not the fact that he will be a good team player.

Most developers stop at this level, especially if they do not plan to study the theory of computer science. Programmers can write decent code and work in the software industry at this level throughout their careers.

From the point of view of the position, programmers are often called “software developers” (Software Developer) or “Software Engineers”.

In a simple example of the sum of an array of integers, a programmer can write code like this:

#!/usr/bin/env rubyif ARGV.size==0
  puts "Usage: "
  puts "   sum [список целых чисел, разделённых пробелами]"else
  puts ARGV.sum{|x| x.to_i}

This code implements a useful command line command to summarize a list of numbers. If called without parameters, it displays a useful usage message. Otherwise prints the standard issue. Here is an example of use: This is a “complex solution”, self-documenting and somewhat abstract, since the program can be called from the command line.

sum [список целых чисел, разделённых пробелами]
$ sum 1 2 3

Researcher: green belt

A computer scientist studied computer science either at school or at work. He has a good understanding of such concepts:

  • Base Base-N (N = 2, 10, 16)
  • Binary operations
  • Boolean logic
  • Algorithmic complexity and big-O notation
  • Data structures (arrays, linked lists, B-trees, red-black trees, queues, stacks, hash tables, heaps, sets, graphs)
  • Sorting algorithms and when to use them
    • Basic understanding of NP-completeness
  • Main multithreaded algorithms
  • Memory management and garbage collection (just because your programming language itself cares about memory management doesn’t mean you can skip this topic)
  • Pointers (you need to at least understand the concept, even if you do not encode in C) and the difference between passing parameters by value or by reference.
  • OOP concepts (interfaces, inheritance, constructors, destructors, classes, objects, abstractions, encapsulation, polymorphism, etc ...)
  • Object Oriented Design and Patterns
  • Recursion
  • Some basic concepts about dynamic programming, greedy algorithms and depreciation analysis, string comparison and approximation algorithms

The researcher has a degree in Computer Science or he worked for many years as a developer, studying applied computer science at work. As you know, I do not think that a CS degree is necessary for a successful developer career .

Just being a “computer scientist” does not make you a great programmer. It seems that the analogy with the colors of the belts is broken. But it is not. Think of it this way: even in the world of martial arts there are specializations. Some green belts do some things better than others. Progression is nonlinear. The color of the belt often represents the level of experience and the amount of labor expended in mastering the martial art, rather than the required level of skill in every aspect.

The scientist will probably write the same code for the sum of the numbers as the programmer. The difference is that a scientist can immediately say that the complexity of this algorithm is O (n) time. As already mentioned, this is an elementary example, but you get the idea.

Software Developer: Blue Belt

A software developer is able to master larger and more complex projects. Compared with the programmer and researcher, he:

  • Writes cleaner, structured, supported, documented and readable code.
  • Allows fewer errors.
  • It works faster.
  • Works best in a team and understands the value of development processes.
  • It finds and optimizes the bottlenecks of code and software systems better.
  • Has more experience.


In a simple example of the sum of integers, a software developer can solve a problem by creating a service that provides a Web API. The interface accepts a set of integers and returns the sum.

I believe that the application will be well documented and maintain the settings, be accompanied by tests, have the correct code structure and are easily maintained by other developers.

On Ruby, the main application using Sinatra might look something like this:

require'sinatra'require"sinatra/config_file"# Load the server configuration from config.yml:
config_file 'config.yml'## EndPoints:## /sum/n1 n2 n3 n4 ...# Return:#     {result: [sum of n1,n2,n3,n4,...]}## Example:#    $ curl http://localhost:8080/sum/1 2 3 4#    {"result":"10"}#
get '/sum/:numbers'do|numbers|
    {result: numbers.split(" ").collect{ |x| x.to_i}.sum}.to_json

A good software developer is well aware of the many limitations of this solution compared to others. For example, it is limited to the sum of a set of numbers that fits into a URI; there is no explicit check for errors, strings must begin with a number, etc.

Software Engineer: Brown Belt

The difference between a developer (software developer) and a software engineer (software engineer) is subtle; I fully recognize this. These terms are usually used interchangeably. However, I assume that a software engineer is a specialist with computer science knowledge and extensive experience as a software developer. The main differences:

  • The ability to create more scalable systems.
  • Durability. They work longer and with fewer problems.
  • Fewer errors and better code quality.
  • Ability to act as a technical project manager and team.
  • Excellent collaboration and communication skills.
  • Adequate knowledge of software architecture to perform work.

In companies, such developers may have posts of “senior developer” (senior developer) or “principal developer” (principal developer).


A software engineer can write an application as a developer, create a service and provide an API to take a set of integers. But I believe that the engineer’s decision will include some improvements:

  • Caching results.
  • Abstraction of the concept from the sum to any mathematical expression in the query.
  • Logging, authentication, hook tracking, etc.

Example becomes stupid

As you can see, too simple an example at this stage becomes a little silly. It boils down to a discussion of how to improve the already redundant solution to a trivial problem.

For example, managing the cache with the results of simple operations on a small set of numbers is most likely more difficult and slower than simple calculations. The cache would make sense if there is a huge array of numbers to pass to the API, but then the list does not fit into the request URI.

You can move the list of numbers into the request body, but then it will no longer be the RESTFUL API, and the request will no longer be cached. At this point, there will be a temptation to change the request to POST, but this way it will never become cacheable. In any case, the discussion can go on and on.

Critical part

See what happens? As the skills of a developer improve and projects become more complex, a funny thing happens. Problems are increasingly moving away from the "main code". Instead, they are increasingly going to handle the context in which the main code works.

As a result, highly skilled developers spend most of their time on improving aspects of the system, such as scalability, performance, error checking, reliability, maintainability, abstraction, portability, handling boundary conditions, etc.

In addition, they will learn how to work more efficiently or improve interaction with other developers and how to approach work in order to minimize risks, etc. Software development moves away from coding in the direction of engineering systems and solutions bounce

Software Architect: Black Belt

All developers and engineers must be able to design the parts of the systems and products they are going to build. “Software Architect” takes this skill to a higher level and makes choices when designing higher-level interactions of larger software systems developed by other engineers.


In our example, among other things, the architect can draw such a diagram in order to direct the development of a service to sum up integers:

To effectively solve such problems, the software architect needs years of experience at all levels. This practical experience is included in muscle memory. It allows the architect to make the right decisions of a high level, without getting hung up on details.

However, I do not believe in clean architects, that is, engineers who make high-level decisions all the time. I think that a reliable architect should go down to the level of individual parts and go out from there when necessary. It is ready to dive into the code regularly and effectively.

In martial arts, the black belt is a teacher and mentor. I think that training and mentoring are also tasks of the software architect. The teaching about which I speak is not direct (lectures), but more is done on an example, showing the way and directing people to make their own decisions.


Serious fighters learn martial art all their lives; serious software developers do the same. Hope you found this discussion helpful. I want to hope that it will provide context to some poorly defined terms, and ideally help explain how to use them more accurately.

Also popular now: