
Having a non-typical tech stack helped us get better candidates - aloukissas
https://blog.agentrisk.com/how-having-a-non-typical-tech-stack-actually-helped-us-get-better-candidates-77d12a7796d4
======
davnicwil
Yeah this is an interesting phenomenon. It's counter intuitive but it does
make sense, if you think about it. I remember listening to a podcast
(changelog I think) with the creator of Elm and he was asked about this - is
it a concern if you build your frontend on Elm that you just won't be able to
find anyone to hire?

His response was that on the contrary, people who use Elm tend to be
enthusiasts by nature and job postings in Elm are rare enough that if you post
one, they will seek it out and come to you, because they really, really want
to be using Elm in their day job.

The alternative, using an extremely popular language/framework, means that
even though the number of enthusiasts out there is absolutely greater, your
job post is just one in a sea of similar ones - so it's much less likely any
candidate is going to seek you out or come to you, based on that alone.

~~~
sfoley
See also: Paul Graham’s essay “The Python Paradox.”

[http://www.paulgraham.com/pypar.html](http://www.paulgraham.com/pypar.html)

------
KaiserPro
I was at the FT when they "adopted" Elixir. (There is nothing wrong with
Elixir, it actually look quite fun. All of the following is process, buisness
and design failures)

That side of the business was a java shop, and had just got 70% through a very
long and expensive migration from some old CRM, payment and auth system, to a
new CRM payment and auth system. (something like 70 people for four years,
lots of design by the CV, Cassandra, and other silly design choices.)

Two devs knew how to use Elixir, they bust out a service, everyone says "Ooo
well done" flung it over the fence and leave. Noone else can really support it
because they are almost all junior java devs. The other departments can't
support it because A) everything was custom, B) only one other person in the
entire company (300 devs) knew elixir. Total defecation show.

So when you see people do something because another company said so, politely
tell them to reconsider.

to translate into a different context:

Project is to build a grain silo. four teams: One team makes the walls, one
the roof, one the vent system and finally the floor.

Roof team decide to use wood, because they've not tried that before, and it
looks good. They are all metal workers. They quickly realise the mig welders
do not perform as well as they do on steel.

Wall team are using corigated galvanised steel and bolts. Start building the
walls, are blocked by both the roof team re-skilling and the floor team.

Vent team decide to use the same, but don't want to use imperial bolts.

Floor team have decided after an away day, that they don't like the current
range of ground anchors, so they have decided to spend six months designing a
new fixture out of carbon fibre.

To tie it back to the article.

There is no possible way to prove the argument with one company, you need a
double blind.

~~~
bitcrusher
No, this is just a fancy tautological development argument. This is how we got
into the Java trap (yes, it's a trap) to begin with. Everyone knows Java, you
can hire Java devs easily, etc. etc. There's really no reason for this other
than: "We don't want to let people grow beyond the cogs we hired them to be".
That may or may not be "good" but at least call it what it is: Broken internal
human factors processes, instead of couching it in pseudo-technical
tomfoolery.

There is literally NO reason (other than time, mentoring and desire) that the
jr. Java developers couldn't pick up Elixir in a short amount of time and be
fully productive.

~~~
carlmr
>There is literally NO reason (other than time, mentoring and desire) that the
jr. Java developers couldn't pick up Elixir in a short amount of time and be
fully productive.

Put in another way. If your devs can't learn a new language that's not super
foreign in 3-4 weeks to a decently productive level, you didn't hire good devs
in the first place. I'm sure they would create a similar dumpster fire in
Java.

~~~
aloukissas
True. But it's a big paradigm shift from OOP to FP with pattern matching and
adopting the "let it crash" approach. But switching from Java to Elixir is a
proven 1000% increase in developer happiness :)

~~~
tracker1
I've generally had the opinion of a _let it all burn_ first approach... in web
ui, first thing I do is mount an error handler for the window and unhandled
promises that effectively clears body and set's its' innerHTML to
<h1>Unexpected Error</h1>. Similar elsewhere forcing the process to exit.

If you're expecting a certain error condition, handle it, otherwise blow up
the world, because you can no longer trust it.

------
xondono
Maybe I’m reading this wrong but, how do you know?

The whole process looks like a test with no control experiment (i.e. a set of
interviews with a more popular stack).

Don’t get me wrong, I’m quite sure Carlos is an amazing engineer, but I don’t
think your stack has much to do with it

~~~
Circuits
It's the human condition to think like this. We tried x method and were
successful; therefore, method x is the right way to do things. No.. no there
are a billion ways to do things and method x just happens to be one of them.

------
ydnaclementine
PG had an essay about this same subject ~15 years ago about python (which was
still up and coming back then). I'm sure you could relate it to a trend graph
with early adopters, hitting mainstream, etc

[http://www.paulgraham.com/pypar.html](http://www.paulgraham.com/pypar.html)

Always excited to see more phoenix/elixir love

~~~
aloukissas
Thanks for the pointer! This definitely should have been a link in the post.
Oh, well.

------
sam_lowry_
With Elixir, you get all escapees from the Ruby on Rails community. They will
work for food to avoid maintaining those horrible RoR 1.x and 2.x web
applications that they produced in their earlier years.

It's a wisely chosen stack, indeed.

~~~
thomasfedb
I've happily raised a handful of Rails apps all the way from 2.x up to 5.2. As
long as you revisit them at least once or twice a year, and aren't afraid to
regex your codebase, you can keep everything fairly modern and pleasant to
work with.

~~~
tracker1
The same is true of many things... that said, when you have an Angular 2.x app
that needs to uplift to current, not fun. Same goes for the Node side itself
as well... man it can be nasty if you don't stay on top of framework upgrades.

------
duxup
I think depending on where you are there is a risk of fewer / not enough
candidates if you're on the leading / uncommon edge technology a bit. It does
make sense though that enthusiasts might be better candidates.

I do wonder though if this might actually be more of a personality type thing
and maybe less "better candidate".

Folks who want to learn something non conventional might be better, but they
also may share personality traits that mesh well too.

~~~
carlmr
>Folks who want to learn something non conventional might be better, but they
also may share personality traits that mesh well too.

Curiosity is probably what they have and what helps in solving problems.

~~~
duxup
Curiosity might also help with working with others too, if directed properly.

Even really awkward folks who apply some logic to their interactions can work
those things out in my experience.

------
massung
I've read many articles along these lines, and I'm gonna say they all suffer
from two logic fallacies:

1\. Correlation != causation.

2\. Confirmation bias.

There was no comparison mentioned in the article (or just about any similarly
purposed article). The author has no - or at least did not state any - insight
as to whether or not _this_ particular bullet point (Elixir) had any impact
what-so-ever on the quality of the candidates that applied. There were no
controls or comparisons made. Just a blind assumption that anyone who applied
_must_ be better because of the language choice.

I have no doubt that the esoteric stack did have one major impact on the
recruiting process: they had a far smaller pool of candidates to draw from.
They weren't wading in resumes, trying to pick out ones that somehow stood
out. And the highly specific details of their stack meant they weren't trying
to ascertain whether or not a given candidate with no direct experience would
be able to "pick it up". They were able (and had to) pay much more attention
to each application. They read each resume carefully. And they were probably
less strict about which candidates got that initial phone screen/test.

There is a likely a bit of correlation between programmer "quality" and
esoteric language knowledge. My experience has been that polyglot programmers
are so because they love to program and do so at work an in their spare time.
They love learning concepts, ideas, patterns, etc. And they have a lot of
tools and (often superficial) knowledge to draw from to solve problems. But,
I've also found that often polyglot programmers are terrible at completing.
Once the perceived, initial, "fun" problem is "solved" their interest and
motivation levels to work through the details, customer feedback, and bugs
tanks.

All that said, I'm glad they were able to hire Carlos, and I hope he turns out
to be the superstar they are looking for!

------
radcon
> However, it turns out that there are a lot of developers that really love
> Elixir!

Turns out it has nothing to do with being non-typical and everything to do
with Elixir.

This is more of an ad for their company than an article on hiring for
unconventional tech stacks.

~~~
aloukissas
This was by no means our intention. We just wanted to share our experience
with the community.

------
wolco
Doesn't work if you are hiring locally. Finding one or two should be a degree
easier than 10 compared to something more popular.

