Which Software Engineer Should You Recruit?

 

Which software engineer should you recruit to your team? What is the difference between a junior, senior and an ace software engineer? What is the expected salary, and does it worth spending it?

A crucial part of a being a senior software engineer and team leader in a software company is the hiring new personal process. This occurs when you're building up a new team for a new project, when the project expands and requires more developers, and when your need to fill in the gaps of software engineers who went seeking other adventures out of the company.

Before starting a recruiting process, we must understand who are we looking for. Support we want a full stack developer, should we hire a fresh newbie just out of the university, or a software engineer that had been out there working for 2 years? 10 years? What if we happen to encounter a superstar, should we hire him and pay the high cost?

Mixed Team

To answer this we should first examine the current situation in the existing team. A general guideline for an excellent team is to have a team that includes up to 7 employees. Most of the employees in the team should be seniors, which means they should have a good experience of at least 10 years. One or two of the employees should be juniors, with experience of 1-4 years. If you're lucky, you will also have a superstar software engineer in the team, with at least 15 years of experience and excellent analytical and performance abilities.

Why do we need such a team? 

We need such a team to create maximum production while avoiding tension. The difference in the team members skills would create a sharing and teaching habit between the more experienced team members to the others. The superstar can technology guide and lead the team while tackling a huge share of the tasks himself. 

Let's examine each of these typecasts.

The Junior

The junior software developer has 1-4 years of experience. The production output from this team member is expected to be very low. It might be even negative production output:

1. The team needs to invest resources in educating the junior software developer.

2. The mistakes and bugs caused by the junior cause production lost, both when fixed during the development process, and when are discovers as bugs on customer deployments.

Still there are benefits for employing a junior:

1. The need to education and information sharing in the team becomes an integral and a legit process in the everyday working process. This benefits both the juniors, but under the surface provides a benefit for the senior team members as well.

2. The payroll of a junior is low.

3. There are many juniors available in the market

4. The junior would eventually become a senior, and in case he chooses to stay in the company, it is a senior with several year of experience exactly in the development domain you need.

5. In the long term, this is the only effective method to train new software developers, that is - by experience, and as a society we should strive to create senior software developers.

The Senior

The senior software developer has at least 5 years of experience, which usually spent in several companies. The production output from this team member is expected to be high. In case you don'y have a superstar in the team, this is where the majority of work is done. 

A senior in the team is expected to have payroll of 2-3 times more than a junior, and it is harder to find a good senior, and the seniors are less available in the market.

The senior is usually limited to few technology domains, for example: 1-2 programming languages, 1-2 development frameworks.

The Superstar

The superstar software developer has at least 15 years of experience. If you are lucky to get one in your team, then you are in good state. The superstar would both lead the guide the juniors and seniors in the team, and would take the heavy-lifting tasks on his own. A production output from a superstar is at least 5 times fold higher than a senior software engineer.

Why?

The superstar has high development rate and high quality code. This means a lot of output, with very few rejects in form of bugs and customer issues. The architecture of the product would usually also handled by the superstar, reducing mistakes that otherwise would have huge impact on the road-map in the future.

The superstar is not limited by domains, any new programming language, and any new framework, is usually taken over in a short period. In most cases, the superstar adapts and enhances the frameworks to the team needs.

A superstar in the team is expected to have payroll of 2-3 times more than a senior, and it is extremely hard to find one in the market.

Rust - I give up!

 For the last 2 months I've been trying to use the Rust language. In the beginning it looked promising - get the performance of a C++ code with a better stability, simpler memory management, everything solved at compile time, and not sorrow hours of trying to solve a memory leak/overrun in runtime.

BUT...

As I've stepped through the Rust Book,  I've discovered the complexity of the compiler getting higher and higher. I've spend hours creating a code that in other programming languages I can do in 5 minutes. It make no sense.

Not only that, I've also discovered the "Smart Pointers" chapter, and the formal declaration:

"

Rust’s memory safety guarantees make it difficult, but not impossible, to accidentally create memory that is never cleaned up (known as a memory leak). Preventing memory leaks entirely is not one of Rust’s guarantees, meaning memory leaks are memory safe in Rust.

"

Oh really?? So why should I spend my time on this? As the applications in Rust get more complex, we are forced using smart pointers, and lose the memory magic of Rust. Suddenly I feel much less motivated to spend time on solving complex compilation when I get almost nothing for this.

To sum:

While Rust is great for simple tasks, such as string parsing, regex pattern, and a short lived tasks that do not save object oriented state in the memory, we can use rust. In such case the compiler complexity is somehow relatively small pain. 

In case we want complex state using object oriented design, do not waste time on rust. Instead use Java or Go or even C++. 

Rust Cargo Workspaces

 

In this post we will review the steps to create a multi workspaces rust project.

For this example we will create a flags parsing library that gets settings from the arguments and from the environment variables, while using defaults if the setting is not configured.

Creating the workspace and crates

First we create a new folder for the workspace, and add the binary create to the project:

mkdir flagger
cd flagger/

Create a Cargo.toml file with the following content:

[workspace]

members = [
    "flags_printer",
 

And then run:

cargo new flags_printer

 

Next we add a library to parse the flags.
We update the root Cargo.toml file:

[workspace]

members = [
    "flags_printer",
    "flags_parser",
]

and create the library crate:

cargo new flags_parser --lib

lastly we add dependency in flags_printer to the flags_parser in flags_printer/Cargo.toml

[dependencies]
flags_parser = { path = "../flags_parser" }

Creating the parser code

The main.rs:

use flags_parser::FlagsParser;

fn main() {
    let mut parser = FlagsParser::new();
    parser.configure_flag("runs","1");
    parser.parse_flags();
}

The lib.rs:

use std::collections::HashMap;
use std::env;

pub struct FlagsParser {
    values: HashMap<&'static str, &'static str>,
}

impl FlagsParser {
    pub fn new() -> Self {
        return FlagsParser {
            values: Default::default(),
        };
    }
    pub fn configure_flag(
        &mut self,
        name: &'static str,
        default_value: &'static str,
    ) {
        self.values.insert(name, default_value);
    }

    pub fn parse_flags(
        &mut self,
    ) {
        let mut last_key = "";
        for argument in env::args() {
            if last_key != "" {
                let value:&str = Box::leak(argument.into_boxed_str());
                self.values.insert(last_key, value);
                last_key = ""
            } else {
                for (key, _) in &self.values {
                    if argument == "--".to_owned() + key {
                        last_key = key;
                    }
                }
            }
        }

        println!("{:?}",&self.values)
    }
}

Rust closures ans iterators

 

Rust provides closures and iterators to enable functional programming. In first look it looks great, like the same nice functional programming in other programming languages, but a deeper check exposes that rust suffers from non friendly requirements. See the following example which demonstrates the weird iterators and closure interactions.

fn main() {
    let mut updated_numbers: Vec<i32> = Vec::new();
    let numbers = vec![1, 5, 4, 7, 8, 9];

    // long and explicit definition of a closure
    let decrement_number = |x: &i32| -> i32{
        println!("decrement a number");
        // here we access a variable from outside the closure scope
        updated_numbers.push(x.clone());
        x - 1
    };

    // short hand implicit definition of a closure
    let increment_number = |x| x + 1;

    // we use iterators to create new vectors
    let incremented: Vec<i32> = numbers.iter().map(increment_number).collect();
    let back_to_origin: Vec<i32> = incremented.iter().map(decrement_number).collect();


    println!("numbers {:?}", numbers);
    println!("incremented {:?}", incremented);
    println!("and decremented back {:?}", back_to_origin);
    println!("we've updated the following {:?}", updated_numbers);


    /*
    It turns out functional programming in rust is no fun!
    iter() - creates a pointer to the items
    filter() - creates another pointer to the pointer to the items
    hence, we have a double pointer in the filter, very unexpected behavior
     */
    let filter_even = |x: &&i32| -> bool { return *x % 2 == 0 };
    let even: Vec<i32> = numbers.iter().filter(filter_even).map(|x: &i32| -> i32 { *x }).collect();

    /*
    This emphasise the complex rust internals.
    we must redefine the closures since the order of actions is different
     */
    let filter_even = |x: &i32| -> bool { return x % 2 == 0 };
    let decrement_number = |x| x -1;
    let odd: Vec<i32> = numbers.iter().map(increment_number).filter(filter_even).map(decrement_number).collect();

    println!("even numbers are {:?}", even);
    println!("odd numbers are {:?}", odd);
}