
The Conjoined Triangles of Senior-Level Development - caffodian
http://frontside.io/blog/2016/07/07/the-conjoined-triangles-of-senior-level-development.html
======
jbandela1
I liked a lot of the article until I got to

>Our hiring “secret sauce” largely stems from the fact that it seems to take
significantly less time for someone with leadership and community skills to
develop technical skills than the other way around. I’m seeing a large number
of people who graduated from code bootcamps 3 and even 2 years ago now handily
and gracefully filling the role of senior developer.

This statement makes me concerned that they have greatly devalued technical
skills. There are not a whole lot of areas where we would consider a three
month course plus 2 years experience anywhere close to being senior. According
to [http://www.plumbingapprenticeshipshq.com/how-to-become-a-
jou...](http://www.plumbingapprenticeshipshq.com/how-to-become-a-journeyman-
plumber/) to become a journeyman plumber (mid-level) requires a 4-5 year
apprenticeship!

When technical ability is devalued so much in a company, there is a real
danger that this turns into a Dunning-Kruger clique, where "senior" developers
that have been programming for 2.5 years automatically favor hiring
experienced business people over experienced developers (remember you can turn
someone who has never programmed into a senior developer in a little over 2
years)

Think about law, medicine, engineering, or the military. We would never call a
lawyer that started training 3 years ago a senior attorney. A doctor after 4
years of medical school is called an intern and basically expected to mess
stuff up. As mentioned above, even a plumber with 3 years of experience is an
apprentice. Why should we as software developers devalue our craft so much?

~~~
jasode
_> This statement makes me concerned that they have greatly devalued technical
skills. [...] When technical ability is devalued so much in a company,_

I'm not going to justify their thinking but I'll attempt to explain where it
probably comes from.

The context for their perspective is crucial. Notice that their assertion for
"less time to develop technical skills" is followed by a sentence praising
graduates of "code bootcamps". They also prominently espouse Ember.js[1].

To make sense of that, we can (roughly) divide programmers into two groups:
(1) CRUD LOB Line-Of-Business (2) algorithmic/embedded

(1) is programming the enterprisey, forms & fields, "back office" apps. It was
COBOL, dBASE/Clipper, Visual Basic, Microsoft Access, C# Winforms, 4GLs like
Oracle Forms & SAP ABAP, and now Javascript frameworks such as
Ember.js/Angularjs. Basically, slapping a client GUI in front of a database
backend. Whether that client GUI technology is Visual Basic, or mobile phone
Javascipt, or iOS Swift app... that choice is more about whatever zeitgeist of
programming you happen to be living in rather than any inherent difficulty
levels between the technologies. The idea is to take the high-level
frameworks+libraries and glue them together to deliver value to the business.

(2) is programming of realtime kernel schedulers, complex distributed
computing algorithms, search engines, database storage engines, machine
learning, ray tracing graphics and physics engines for video games, audio DSP,
traversing graph nodes, control theory for drones and Mars Rover, etc. This
would be more "engineering" type of coding rather than "integration/glue"
coding. Typical programmers we'd think of in this group would be Jeff Dean
(Google MapReduce/Tensorflow), John Carmac (Doom), Fabrice Bellard (ffmpeg).

The programmers in group(2) wouldn't say it's easy to take "leaders" and add
programming skills to them. However, that sentiment is often expressed by
group(1) programmers. I'm not saying it's the "right" philosophy but it's an
observation I've seen repeatedly. The CRUD programming is often seen as just a
longer more elaborate version of programming the Tivo / thermostat / lawn
sprinkler system. It doesn't seem like group(1) is "devaluing" themselves but
instead, they honestly just think "programming skill" isn't really a big deal.

[1][http://frontside.io/ember-consulting/](http://frontside.io/ember-
consulting/)

~~~
Domenic_S
I like this. I'd elaborate on your groups this way:

Group 1's job is to save the company money, or make existing systems easier to
use/more efficient. They help increase sales by implementing metrics/ab
testing/etc. A top member of group 1 will be leveraging technology to automate
costs & complexity away. If the company nets more money because a Group 1
person is employed, they're doing their job.

Group 2's job is to invent core technology, often from scratch. They are well-
versed in theory and application, and their deliverables take lots of time. If
the company gains a patent because of a Group 2 person, they're doing their
job.

Group 1 is business (and sometime public) facing, so soft skills are much more
important. Group 2 IS usually the business, so tech skills are #1. The two
groups have the same components in their pie charts, just in different
proportions.

~~~
clay_to_n
That's not always true - many businesses make a lot of money with a core
product in Group 1.

Group 2 is only necessary for certain companies, where leveraging technical
advantages is core for the business. Most startups are not this, though being
one maybe helps a startup's chances of success.

------
j-c-h-e-n-g
I have bookmarked John Allspaw's thorough writeup about this topic because I
figure it's worth re-reading to internalize:
[http://www.kitchensoap.com/2012/10/25/on-being-a-senior-
engi...](http://www.kitchensoap.com/2012/10/25/on-being-a-senior-engineer/)

He also makes reference to the Dreyfus model of skill acquisition which is
worth keeping in mind:
[http://en.wikipedia.org/wiki/Dreyfus_model_of_skill_acquisit...](http://en.wikipedia.org/wiki/Dreyfus_model_of_skill_acquisition)

~~~
mafro
This. I've shared this definition with a number of aspiring seniors over the
last few years - Allspaw describes "senior" far better than I ever could.

------
RangerScience
I really liked this! I will also have to think on it more.

However, I think you sell the initial idea short - that seniority DOES
ultimately boil down to direction required / direction provided.

The only place this summary would fall short are in those people who can bust
out anything on their own in record time, but have trouble with teams... and
even they provide direction, if only by setting a technical direction/example.

When you expand to the venn diagram, you're elaborating on the _kinds_ of
direction that can required or provided, but that core remains - that
ultimately, seniority happens as you go from needing direction to providing
it.

Now, within in different industries, the points within each circle can change
(compare startups, where now is better than perfect, to industrial plants,
where perfect is better than now, to research, where now and perfect are
sacrificed to hard and novel).

I'd say it's even likely that, given a different culture and/or problem domain
and/or ???, you get different circles entirely - although it's hard to argue
with "ability to do the job", "ability to work with others" and "ability to
cause direction". What are things that _don 't_ fit into one of those?

~~~
RangerScience
Although, thinking on it more - seniority (in a category, rather than overall)
being defined by "providing versus needing direction" misses the axis of
_receptivity_ to outside direction. Think of the over-eager "junior" dev too
full of ideas to hear anyone else's, or the "senior" dev to full of knowledge
to accept any more...

------
partycoder
"Senior developer" is a job title. Think of it as army ranks, each national
army might have their own names and ways or promoting others.

Some people also argue what is the difference between calling yourself coder,
programmer, software developer and software engineer, and even taking the
debate as far as questioning if a software engineer is an actual engineer.

To be honest, these debates are sort of empty unless there is clear regulation
and disambiguation around what seniority is. You can define seniority in many
ways.

~~~
sanderjd
I think you've missed the point of the article. I thought it was going the
"debate over words" direction you're responding to, but it ended up being a
lot less about what the word means, and a lot more about what the concept of
"seniority" in our field entails, which is a lot more interesting.

~~~
partycoder
Well, I respectfully disagree with the Venn diagram in the article. You can be
at the center of that Venn diagram and still not be a senior engineer.

------
t_fatus
Make it three-dimensionalby adding a fourth circle with C-level skills and
you've got the CTO diagram ! Seriously this is by far the smartest thing I've
read associated with "senior developer", and can be of great use when hiring
decisions need to be made.

~~~
foxbarrington
What are some C-level skills?

~~~
t_fatus
Probably not the best word ... More like : * be able to stand in front of
investors and explain where you want to see the company in 5Y, and why *
create a great culture everybody share * speak a language sales people, HR
people, tech people, devops people, legal people can understand, and be
curious about their different jobs

------
emblem21
My problem with these sorts of discussions is that they try to put technical
know-how on the same footing as social aptitude, charisma, and other "soft
skills".

I can throw darts on a map and find billions of people capable of
"connectedness" and "leadership". Finding you capable "technical" talent on
the other hand...

This ease is mostly due to connectedness and leadership being naturally grown
out of decades of organic social interactions that people need to do in order
to... you know... survive. You can accidentally reinforce these properties
just by being 1.) a member of the human species and 2.) alive.

No one accidentally reinforces the understanding required to mentally maintain
the thousands of arcane exceptions written by the result of C-Levels pivoting
endlessly across outsourced teams for the cheapest price, compiling the
world's worst spaghetti code responsible for an everything-on-the-line
application.

And if this seems a bitter, then look into your own organizations and
experiences: Who gets fired/quits the most? Human Resources, C-Levels,
Marketing or the Technical team? Whose ass is on the line when the fires
start? Who is expected to work 10+ hour days every day for all of eternity?

Looking for unicorns does not make you a unicorn hunter. It makes you
delusional. A senior knows unicorns don't exist even if people look to him/her
as one.

~~~
serge2k
> My problem with these sorts of discussions is that they try to put technical
> know-how on the same footing as social aptitude, charisma, and other "soft
> skills".

You really do need some level of each.

Difference is you can reach a pretty low bar in term of social skills, being
approachable and being able to communicate, vs a high bar technically.

------
ilaksh
Its really mainly a rationalization for paying some people more than others.
Or just a way of rating some developers as being more valuable.

If it were popular to use Programmer I, Programmer II, and Programmer III,
then they would call it that.

By the way, going to a lot of conferences or having a lot of Twitter followers
does not make you more 'senior' than me. It might make it easier for you to
negotiate a 'senior' title and salary though, just by virtue of your being
good at self-promotion.

~~~
mpeg
They do, in lots of companies, have "Software Developer I", "II", "III" ...

Or MTS/SMTS/LMTS/PMTS with a gazillion different levels for each

------
sjclemmy
I think this is a great analysis. We like to think that jobs are clearly
defined, but in reality they aren't, and they differ from company to company.

I have spent many a year being as a mid-level exec in medium size companies.
Wherever I've been, I have demonstrated ownership and leadership (I'm not
bragging, that's just how I work). However, I have alway felt a 'lack' of
technical expertise, probably because I fit so well into the leadership roles
I never spend that long on 'deep' technical work. Recently, I have sought to
remedy this. I have traded my mid-level 'get stuff done' to become a
developer, to scratch an itch that has been there since I programmed BASIC on
my ZX Spectrum. I'm no spring chicken and I have spent the past 5 years
getting up to speed on modern web and mobile development techniques and have
pushed myself as a developer to anyone who will listen. In my latest role I've
already been earmarked for a lead developer role - and I think this validates
what the article is saying and also what a few comments on here are saying; I
have demonstrated that I am technically competent with 3-4 years solid
experience (which for 90% of jobs out there is probably enough), but my
approach to working; owning problems and solutions, leading and mentoring
others show that I can be relied upon to deliver product.

Just to counter the self-congratulatory tone of the above (I'm English, it
makes me uncomfortable), I'm acutely aware of my shortcomings both technically
and personally; I should write more tests, I should plan more before writing
code, I sometimes don't speak up because I don't want to look stupid etc. But
I think everyone has shortcomings that they learn to accommodate or change,
it's all part of life.

------
randomnumber314
In my experience a senior developer is a lesser-title for a CTO. A senior
developer is someone who knows the company's mission, knows the technology,
and knows the team. From there they evaluate what the board/CEO/kid with a
plan want and develop a strategy to get the not-senior developers to implement
that plan.

Key characteristics: _Not chasing every new and shiny framework /tech
_Singular focus on stated objectives/milestones/deliverables _Understands "big
picture" as well as the granular details, so that they can provide advice and
leadership about implementation _Acts as buffer between "techies" and
management in every cycle of iteration

It's very likely that my bullets are worded poorly, but my overall point is
that a senior developer is someone who has the experience to liaison between
those with ideas and those with technical skills. In some environments the sr.
dev is the person doing the tech work, in other environment they're leading a
team, in any case they have the knowledge, skills and experience to produce
results.

~~~
collyw
That sounds closer to management than developer.

~~~
randomnumber314
That's why I said 'lesser title for CTO.' They don't necessarily manage a
project, so much as act as a leader for channeling communication between
management and coders.

~~~
nilkn
This makes sense for very small companies, but maybe not so much for large
companies. For instance, a senior developer at Google is miles away from the
CTO (or equivalent position). There you've got senior developers, staff
developers, senior staff developers, directors of engineering, distinguished
engineers, etc.

------
mooreds
I found this a thought provoking post, but the true value was that "senior"
means different things at different companies. A senior dev at Oracle will
need a vastly different skillset than a senior dev at a startup.

(The Venn diagram is a nice starting point, though.)

So, when you are looking at jobs or hires, always consider the context.

------
moron4hire
If you can't define how to hire for a senior developer, it is probably because
you can't define the job of a senior developer. I know this is pretty much
stated in the article, but the greater implication seems to be missed. Senior
developers are those that bring definition to the undefined.

I believe you don't hire people for jobs they've done, you hire people to do a
job, and you ultimately fire people for not doing their jobs. What they did in
the past might have zero bearing on what the person is capable of doing. A
resume only tells you how good they are at writing resumes (especially if you
don't follow up and confirm it, and who has time for that?)

Admit that the criteria is undefined, and stop trying to have control where
there is none. Put people on the job without interviewing then [0]. Fire them
if they prove they can't do their job. But I think it is much more likely that
you will find yourself surprised by a person stepping up to the challenge
presented to them.

The job doesn't care how you found the candidate to do it. You don't really
have any control, anyway. So quit wasting time (and money) on the process.

[0] at least, not in this way. I prescreen candidates for general intelligence
and social graces. We do not hire people who think it's ok to tell racist
jokes at parties. Unfortunately, this is a recurring issue.

~~~
Dayshine
> Fire them if they prove they can't do their job.

What kind of timescale would you consider reasonable for this?

Because the cost of changing jobs once you have a family means anything less
than 3 months is pretty unethical. Unless you tell them up front, but that's
just probation, which means good luck hiring anyone.

~~~
moron4hire
I do not agree that it is unethical to fire someone before three months, but
it's not been an issue, I've neither had to do it that early. I do think it's
more unethical to keep a person in a position for which they are not suited,
though, regarding your responsibilities towards the company, to the worker in
question, and to their co-workers.

I am up front about the process and the possibility it could end very early. I
typically suggest to them that they start at 10hrs/wk while at their current
job to see if they like the work. I've not found it difficult to hire people
in this way.

~~~
serge2k
> I typically suggest to them that they start at 10hrs/wk while at their
> current job to see if they like the work.

ha. Good one.

oh wait you're serious. Noooooooooooooooooooooooo

~~~
moron4hire
I do what works for me. The best people I've ever hired were all this way. I
don't think I deserve such shitpost replies in return.

~~~
serge2k
The whole idea of "just work for us for a while" is so ridiculously employee
hostile I couldn't resist mocking it.

The idea that I should risk my current job for a chance at working elsewhere
is terrible.

------
issa
I've always thought about it this way: A Senior Developer can tackle a large
project (alone or leading a team) without technical help. A Junior Developer
would need some guidance with a variety of things from choosing tools and
approach to scaling and interfacing with existing infrastructure.

