List of technical roles that can be found on almost every software project nowadays.
The “traditional” technical roles are Developer and Tester. There is also a bunch of other (“additional”) technical roles like DevOps, Support and more.
The following chart demonstrates the difference between the ability to write code for the various technical roles:
Let’s describe these roles now, without diving into too much detail, as we will cover them in individual articles later.
A developer is a guy (or a girl :-) who maintains the existing code and writes new code.
Most of the developers would probably agree that writing new code is much more fun, but in reality, their job is a lot about reading, understanding, fixing, improving and enhancing the existing codebase.
The most important things that developers use are:
- Programming Language
- Versioning System (to keep track of the code changes)
- IDE (to write, run and debug the code easily)
- Frameworks and Libraries (to reuse common functionality that has been already written, thus develop faster)
- Other Tools (dependency management tools, continuous integration tools)
These will be discussed later.
Tester (Quality Assurance)
A tester is a person who makes sure that developers did a good job.
Testers test the application or its parts to check that everything is in line with the requirements and there are no bugs. Some basic testing is naturally done by developers first, but testers are the ones who really try hard to break things and throw it back onto developers.
We can divide testers into two basic groups - manual testers and testers with automation. There seems to be a visible trend of moving towards the automation more and more, especially for larger projects.
Manual testers test the application’s overall functionality, new features, and also make sure that changes do not break existing features.
Some projects require testers to write and execute test plans and test cases, whereas some projects might be less formal and let testers work in a more ad-hoc way.
The most important thing that manual testers use (apart from the application being tested) is a bug-tracking system.
Tester with Automation
Testers with automation have the same purpose as manual testers but achieve the goal in a bit more sophisticated way.
They are basically writing scripts that, once run, do automatically what a manual tester would have to do manually. That means more effort initially (writing the script) but much less effort later on, because, as you can imagine, re-running a test is a breeze.
Let’s take a web application for example, where we probably want to make sure that a user can log in, and it is very important to make sure this functionality never breaks.
So where a manual tester would have to try to log in with some demo account each time a new feature has been added (sounds like a manual and boring task, huh?), a tester with automation rather writes a script which carries the mundane test for him and only reports problems, should there be any.
As you can see, there is not such a big difference between a developer and a tester with automation in a sense that both of them write code.
Furthermore, the test script(s) can even run automatically each time a developer pushes new code, which is an important part of a concept called continuous integration.
The most important things that testers with automation use are the same as what developers use plus:
- Automation Testing Framework (to create and run tests)
- Bug-tracking System (to keep track of bugs and fixes)
DevOps (as in Development and Operations) engineers take care of servers and applications, and their typical tasks include:
- Server Provisioning (creating servers, installing operation system)
- Software Installation (installing web servers, application servers, and other necessary software)
- Server Configuration (e.g. configuring networking and firewall)
- Application Deployment (taking the application developed by developers and putting it on server)
- Monitoring (making sure servers and applications are running properly)
- Other (e.g. taking care of the whole continuous integration flow)
DevOps are not developers in a traditional sense but they usually know at least one scripting language (Ruby, Python) and basic shell programming (Bash), which makes their life much easier (task automation).
Many organizations require DevOps to be on a 24/7 duty, to make sure the critical software is running properly at all times.
The most important things that DevOps use are:
- Server Virtualization (VMware, Xen, Vagrant, Docker)
- Server Automation (Puppet, Chef)
- Repository Management Tools (Sonatype Nexus)
- Continuous Integration Tools (Jenkins, TeamCity)
- Monitoring Tools (Nagios, Sensu)
There are usually three lines of support, varying in the complexity of problems they can solve. The first line is usually the first point of contact and the problem is escalated to further lines of support, if necessary.
The first-line support people deal with simple problems like forgotten passwords. More complicated things get passed to the second-level support.
The second-line support personnel is usually more experienced and knowledgeable and can do things like running a SQL query to check data in the database or running a simple script and similar. They can also collect useful information and pass it to the third-level support, if necessary.
These are usually developers of the software themselves. They deal with issues that need deeper investigation, often resulting in a bugfix or other code modification.