
Ask HN: How do you automate developer onboarding? - pageandrew
What tools do you use to automate the on boarding of new developers, and the setup of new machines?<p>We have a bunch of dependencies that need to be installed, scripts that need to be injected into their bash profile, configuration files to update, etc.<p>Right now, we have a messy collection of Bash &amp; Ruby scripts that the developer has to run (and continuously run as updates are made). Wondering if theres anything better out there?
======
PaulKeeble
You could also dockerise the development environment. Rather than having
people run these things on their Linux install you can just run a docker
environment with it already setup. Then upgrades become easy pulls and running
them.

I recently moved to using docker for the common development tools and it has
made changes a lot easier. I also read somewhere about using DISPLAY for X
programs with docker and so now even the IDE can run in one as well. It takes
a while to set it up but it doesn't have the overhead of VM solutions like
vagrant and with docker-compose it ends up really easy to just have in a git
repository making setup just a git clone and docker install and then docker-
compose up.

------
Terretta
Examples of brittle but approachable approaches we’ve used:

\- Literate bash:
[https://github.com/bashup/mdsh](https://github.com/bashup/mdsh)

\- Ansible: [https://github.com/bmacauley/ansible-playbook-mac-
dev/blob/m...](https://github.com/bmacauley/ansible-playbook-mac-
dev/blob/master/install)

\- Kubernetes: [https://abhishek-tiwari.com/local-development-environment-
fo...](https://abhishek-tiwari.com/local-development-environment-for-
kubernetes-using-minikube/)

Example of solid and shareable at scale approach, takes a bit of rocket
surgery:

-Nix: [https://dzone.com/articles/isolated-development-environment-...](https://dzone.com/articles/isolated-development-environment-using-nix)

To be clear, we had a Nix committer to help work through kinks. But once all
of your team members, local and remote, have lockstep dev environments
versioned with the code commits, several other classes of hair pulling go
away.

------
meesterdude
My advice, fwiw: make things more boring and less special. Reduce cleverness
and surprises where possible. (I realize this isn't always possible)

Automating on-boarding is possible, but it is usually better to have good docs
that breakout into different systems like OSX, windows, Debian/fedora and just
have good copy-paste from there. That allows for tweaks to be made more easily
when things go wrong, and to update for future devs.

If you really need to automate, write your own installers to do the work
inserting code, installing dependencies, etc and expand to support different
systems where necessary. This can be as simple as a github repo that you
pulldown and run an installer for, that automatically hooks in to the shell
and provides an easy path for updates.

------
jorisd
If managing shell scripts becomes too unwieldy, you could use Puppet or
Ansible to provision your local machine, just like you would when you'd use
these tools to provision a new server instance elsewhere. This works great
when you combine it with a Virtual Machine managed through Vagrant. The guest
OS is then managed completely via Vagrant and Ansible/Puppet, and the only
host OS software you then need is a working Vagrant environment, which can
often be installed completely through the OS's package management system.

------
twunde
For laptop setup at a company you should be using some sort of MDM software.
It's essentially configuration management, but with the understanding that
this is for users who will want to change things. If you're an all Mac shop,
take a look at Jamf or at Fleetsmith. If you've got a mix, there are some
products like Airwatch that support Windows and Mac. These tools allow you to
set up applications and configurations. I generally run a white-listed "app"
store where users can download apps, scripts and new configurations. Or
alternatively you can force install anything you really need.

I'll also second using Docker or virtual machines if possible. It makes the
setup and continued support _much_ easier.

------
corporateslaver
Just write a bash script

------
stephenr
Vagrant mostly.

We build a custom vagrant box with dependencies pre-installed, and then run
setup on top of that.

Admittedly we don’t have many “tools” like you mentioned - just a couple of
shell scripts in the git repo itself.

If you need to install host OS level software I’d just write some shell
scripts to automate the steps.

------
nannooo
You could create an image with everything preinstalled. Just install it and
you have a lot of stuff ready right away.

For things they have todo / resources they should look through, you could use
ChiefOnboarding.com (Full Disclosure: I have built this)

------
arnvald
Have you tried Boxen?[1]

It allows you to automate installing libraries and running scripts by writing
Puppet manifests.

[1] [https://github.com/boxen/our-boxen](https://github.com/boxen/our-boxen)

------
simon_acca
Have you considered writing packages for whatever package manager your OS
uses?

