
Ask HN: How do you install developer tools on a fresh system? - fratlas
I used to have a bash script I would run to install everything (libs&#x2F;tools) you&#x27;re average web developer would need (node, sublime, google chrome, , python libs etc etc). Unfortunately I lost it after some time. Does anyone use anything similar?
======
falcolas
I don't do fresh installs very often, but when I do, it's generally because I
want it to be a genuine fresh install. As such, I don't install a tool until I
need it. I find that tools I once thought I absolutely needed are not tools or
libraries that I use anymore.

I have three exceptions to this: Vim (my editor of choice), dotfiles (which I
store in a git repository and put in place using stow, installed via a simple
bash script), and Vagrant, so I can do development testing against a VM.

As Docker matures, I may use it in place of Vagrant, but it's not ready to
fill the same role quite yet.

~~~
moondev
Have you tried the beta for OSX or Windows yet? I haven't needed vagrant in
the slightest since it was released.

~~~
falcolas
If they can get xhyve based VMs stable when co-existing with VirtualBox, then
yeah, that will go a long way towards replacing Vagrant for me.

That said, I'm not a huge fan of Docker's feature churn; having to re-install,
reconfigure, and re-learn tooling that is central to my workflow every other
month gets old pretty quickly.

~~~
gtirloni
That's currently blocker #1 for us when it comes to the new Docker for
Mac/Win. VirtualBox works as a nice abstraction layer on top of 3 OSes
(Mac/Win/Linux) which simplifies things with Vagrant. Unfortunately it seems
VirtualBox has been in maintenance mode as of lately so that might have
contributed to Docker's decision to go with HyperV/xhyve.

------
fratlas
Oh god I used "you're" instead of "your" and can't edit it.

~~~
orf
The horror!

~~~
fratlas
I have become what I hate :(

~~~
aug-riedinger
You only hate not being able to edit your comment on HN. So do I.

------
mbrock
I recently reinstalled my NixOS laptop. I just installed the distribution,
added my SSH keys, cloned a repository, made a handful of symlinks, and then
told NixOS to set everything up.

It's actually a collaborative repository, so that both of us in our company
can improve the computer configuration, install new tools or language
runtimes, etc etc.

The shared configuration has stuff like: our user accounts and public SSH
keys; local mailer setup; firewall; conf for X/bash/emacs/ratpoison/tmux; list
of installed packages (including Chromium, mplayer, nethack, etc); fonts and
keymaps; various services (nssmdns, atd, redis, ipfs, tor, docker, ssh agent,
etc); some cron jobs; a few custom package definitions; and some other stuff.

In Emacs, I use "use-package" for all external package requirements so that
when I start the editor it installs all missing packages from ELPA/MELPA.

Aside from dealing with the binary WiFi blob this Dell computer demands,
reinstalling was a pleasure.

~~~
nahtnam
You can use nixOS as a development machine? How did you install a window
manager or desktop environment?

~~~
mbrock
Sure! It's a full distribution. You install window managers the same way as
any other package. The NixOS manual is quite comprehensive.

------
dvcrn
I have my dotfiles for that. Split into different categories (brew, npm, pip)
together with all the config files I need. brew and brew cask (with brew-
bundle [0] for Brewfile support) take care of getting all libraries and
applications onto the system.

For the development itself I'm either shipping my entire config (.vimrc for
example) or use systems like spacemacs, sublimious or proton that only need 1
single file to re-install the entire state of the editor.

The install script itself [1] is then symlinking everyhing into place and
executes stuff like pip install -r ~/.dotfiles/pip/packages.txt.

It takes a bit of effort to keep everything up to date but I'm never worried
of loosing my "machine state". If I go to a new machine all I have to do is
clone my dotfiles, execute install.sh and I have everything I need.

On servers I am using saltstack [2], a tool like puppet, ansible and friends,
to ensure my machines are in the exact state I want them to be. I'm usually
using the serverless version and push my states over SSH to them.

[0]: [https://github.com/Homebrew/homebrew-
bundle](https://github.com/Homebrew/homebrew-bundle)

[1]:
[https://github.com/dvcrn/dotfiles/blob/master/install.sh](https://github.com/dvcrn/dotfiles/blob/master/install.sh)

[2]: [https://saltstack.com](https://saltstack.com)

~~~
DigitalJack
I have no strong opinion here, but I am curious to hear yours. What were the
discriminators in choosing saltstack over the alternatives?

My head spins with these tools and every time I pick one I seem to eventually
run into a road block that is a no-go. The most recent effort was ansible and
the no-go was its strict dependency on python2.7.

~~~
dvcrn
I came from puppet and salt felt a good amount "lighter". I'm mostly a python
developer and salt states written in pure yaml with jinja2 templates, or
alternatively directly in raw python for more complex stuff feel like home.

The yaml makes it very easy to understand even if I come back to a state after
months. It's just a list of things that should happen with a few template tags
sprinkled in.

Not saying salt is better than puppet or friends. It's purely based on
preference. I can't say anything to chef or ansible since I never tried them.
Salt has a crazy active community and while there are things I don't like
about it like the "name" of a state, it's still doing it's job just fine so I
sticked with it.

~~~
guitarbill
ha, i moved from chef to ansible for much of the same reasons. at the end of
the day, it doesn't matter.

(however, from my experience salt and ansible stay readable because they're
yaml and not arbitrary code/DSL, whereas chef "recipes" are ruby and usually
devolve into complex programs if you're not careful)

------
JoshTriplett
If you consistently use the same Linux distribution, consider building
metapackages for that distribution.

I created a set of Debian packages that depend on suites of packages I need. I
download and install "josh-apt-source", which installs the source in
/etc/apt/sources.list.d and the key in /etc/apt/trusted.gpg.d/ , then "apt
update" and "apt install josh-core josh-dev josh-gui ...". That same source
package also builds configuration packages like "josh-config-sudoers".

~~~
Shorel
Can I use that with external PPAs?

Or I have to install the PPAs before I can use the metapackage (which kind of
defeats the idea of using a metapackage instead of a script)?

~~~
stephenr
While you could have third party repos installed via apt packages the problem
is you can't trigger an apt update after they install and before the things
that depend on them install easily.

------
zihotki
The question asks only about *nix systems, I assume, but it worth mentioning
that there is a great tool for Windows too, just in case if someone needs it -
[https://chocolatey.org/](https://chocolatey.org/)

~~~
j_s
Automating from-scratch setup with chocolatey:
[http://www.boxstarter.org/](http://www.boxstarter.org/)

~~~
skeoh
Looks cool but I would be uncomfortable using this over HTTP, not HTTPS. Don't
really want to risk a MITM when installing software on your machine (and
giving it UAC _and_ your password).

------
Jedd
Use a configuration management tool (I picked
[https://saltstack.com/](https://saltstack.com/) , mostly because of the docs
& community support) but there's lots to choose from - Chef, Puppet, Ansible,
and so on.

There's a learning curve, and plenty of 'where did my afternoon go?' rabbit
holes you can lose yourself in. But the upside is that you can have
consistent, repeatable, and rapid builds, with modularity as a bonus.

Don't be afraid with any of these kinds of tools to brute force complex
components if you're in a hurry - ie. ignore the pure / idiomatic way, and use
the tool's primitives to dump a shell script on a remote box and then run it.

~~~
ams6110
I've found with Ansible at least, I was initially tempted to make large
complicated roles for things like "application server" or "development
desktop" but what ended up working much better was very granular roles such as
"nginx server" and "emacs" (often just a single task such as "yum: name=nginx
state=installed") that can be combined in playbooks. This makes it easier to
avoid duplicating tasks in different roles, or having a lot of complex
conditional cases in your roles.

~~~
snuxoll
This is the "roles and profiles pattern" in puppet, it generally makes sense.

Also, +1 for using CM to set your workstation back up, I really need to get
around to writing some Puppet manifests to do that for mine

------
_query
I'm using a shell script together with the nix package manager for that. The
shell script just ensures that all packages are there (e.g. doing `nix-env -i
fpp wget iterm2 jekyll ghc ruby nodejs composer php`). I can pin the version
of all packages by configuring `NIX_PATH` to point to a specific `nixpkgs`
(the package repository) commit. So that all people have exact the same
versions of everything.

Package customizations like a .vimrc is also handled by nix (I recently
blogged about how I do this:
[https://www.mpscholten.de/nixos/2016/05/26/sharing-
configura...](https://www.mpscholten.de/nixos/2016/05/26/sharing-
configuration-across-systems-with-nix.html)).

The shell scripts together with the package customizations (e.g. my custom
vimrc) are managed by git.

~~~
akavel
I've recently learned you can put all the packages in one custom Nix
expression in ~/.nixpkgs/config.nix, like below, then load (and
reload/update/change) it with one `nix-env -i all`, or faster with: `nix-env
-iA nixos.all`:

    
    
        # ~/.nixpkgs/config.nix
        {
          packageOverrides = defaultPkgs: with defaultPkgs; {
            # To install below "pseudo-package", run:
            #  $ nix-env -i all
            # or:
            #  $ nix-env -iA nixos.all
            all = with pkgs; buildEnv {
              name = "all";
              paths = [
                fpp wget iterm2 jekyll
                ghc ruby nodejs composer php
              ];
            };
          };
        }
    

and then keep only this one file in git. (Though still working on how to
possibly also keep .inputrc, .bashrc, .profile, etc. in it.)

------
pwnna
I've found ansible to be okay at setting up my environment. I'm able to
configure everything from my zsh themes, terminal font size, window manager
shortcuts, thunderbird logins, and so forth. The playbook takes about 30
minutes to run and after that I have almost everything ready.

Unfortunately I don't have a public GH repo I can point at as I don't want to
expose everything I use to the internet. However the principle is the same as
provisioning servers with ansible.

The only thing different I do is I use GPG keys to decrypt and untar things
like thunderbird profiles rather than using Ansible vault. I restore GPG keys
+ SHH keys from offline, encrypted USB backups.

~~~
ajford
Have you considered using Gitlab? I really like GitHub, but can't justify the
prices right now (just starting out in my career). But while Gitlab isn't as
popular, or maybe quite as polished (though it's getting there fast), it does
have free private repos. I've used this to store private data like this.

Check it out if you haven't already.

~~~
pwnna
I use both GL and GH regularly (I have private repo at GH as well). I'm moving
towards GL slowly but my experience is that it is much slower than GH atm.

------
jmfayard
That's a very good reason to only install apps with a real package installer.

On OSX, this is a no-brainer with brew[1] and brew cask[2]

# On my old mac

    
    
      $ brew list
      $ brew cask list
    

=> then I save relevant parts for future references

    
    
      brew install npm
      brew install zsh
      brew cask install sublime-text
      brew cask install google-chrome
      brew cask install intellij-idea
    
    

[1] [http://brew.sh/](http://brew.sh/) [2]
[https://caskroom.github.io/](https://caskroom.github.io/)

~~~
desdiv
>brew list

Protip: "brew list" will list all installed packages, including dependencies,
which you might not want. What you probably want is "brew leaves", where it
lists all installed packages _that are not dependencies of another installed
package_.

This makes a difference in cases where a dependency is no longer needed in the
latest version.

On a related note, why does the majority of package managers make the common
and simple task of "list all manually installed packages" so incredibly hard?

For a fun brain twister, try to list all the manually installed packages on
your system by just reading the man pages and no internet. Ubuntu is nightmare
mode for this challenge.

~~~
jmiserez
For Ubuntu, look no further:
[http://askubuntu.com/a/492343/145754](http://askubuntu.com/a/492343/145754)

------
svaksha
I use a shell script for a new debian[0] installation and also have other
scripts for kubuntu[1], opensuse[2] and other software installations. I store
my dotfiles[3] and other useful scripts that I can customize for each
development environment. Hope that helps!

[0] [https://github.com/svaksha/yaksha/blob/master/yksh/apt-
debia...](https://github.com/svaksha/yaksha/blob/master/yksh/apt-debian.sh)

[1]
[https://github.com/svaksha/yaksha#2-folders](https://github.com/svaksha/yaksha#2-folders)

[2]
[https://github.com/svaksha/yaksha/tree/master/yksh](https://github.com/svaksha/yaksha/tree/master/yksh)

[3]
[https://github.com/svaksha/yaksha/tree/master/home](https://github.com/svaksha/yaksha/tree/master/home)

~~~
noxToken
Just wanted to compliment you on the documentation in those scripts. I'm that
documentation stickler guy at work, so seeing it in the wild (especially for
personal files) makes my day.

~~~
svaksha
Thanks :)

------
Sir_Cmpwn
I just install stuff when I run into something I need but don't have. Keeps my
system slim.

------
ramblenode
Setting up a new system is where NixOS really shines. Once you have one system
working it is trivial to duplicate it on new metal.

1\. Install NixOS

2\. Copy configuration.nix*

3\. Copy dotfiles

4\. # nixos-rebuild switch

5\. Enjoy your old setup on new hardware--no secret sauce needed!

*A hardware-configuration.nix should have been generated by the installer. By default this is sourced by configuration.nix, in which case configuration.nix shouldn't need editing.

~~~
dleslie
I've been interested in Nix and Guix for some time; would you be able to
comment on the two?

~~~
ramblenode
Probably the definitive document making the case for Nix (and Guix by
extension) is Eelco Dolstra's PhD thesis [0] . The introduction is a good read
by itself.

I have never used Guix/GuixSD but have heard good things about it. Behind the
scenes it uses the Nix package manager and offers a subset of Nix packages
licensed as free software. Whereas Nix/NixOS uses the Nix expression language,
Guix/GuixSD uses a Guile Scheme front-end. I've heard the Guix CLI is quite
nice and a bit more polished than Nix's but Nix is currently in the process of
overhauling the CLI. See [1] for a more detailed comparison.

Both of these projects have very active development but don't have the volume
of listings as you would find in e.g. AUR or the Debian repos. That said, I've
been pleased and actually surprised at just how many packages exist. If you
can't find what you want, contributing new packages isn't too hard (often just
a case of finding something similar in the repos and changing the relevant
values). You can check the current Nix [2] and Guix [3] packages here to see
if enough of your needs are covered before giving one of them a try.

[0] [http://grosskurth.ca/bib/2006/dolstra-
thesis.pdf](http://grosskurth.ca/bib/2006/dolstra-thesis.pdf)

[1] [http://sandervanderburg.blogspot.com/2012/11/on-nix-and-
gnu-...](http://sandervanderburg.blogspot.com/2012/11/on-nix-and-gnu-
guix.html)

[2]
[https://nixos.org/nixos/packages.html](https://nixos.org/nixos/packages.html)

[3]
[https://www.gnu.org/software/guix/packages/](https://www.gnu.org/software/guix/packages/)

~~~
dleslie
Thanks!

------
MaulingMonkey
Manually. I wipe rarely, and change tools often for various reasons (even
ignoring version upgrades), making building and maintaining an installation
script not worth it.

For awhile I did maintain a windows batch script that installed things off of
a share at work. I was dealing with pre-release Windows 8, and wiped
frequently for upgrades. Even that probably wasn't worth it, but I didn't have
a second machine at the time, and wanted to run it overnight instead of
blocking my ability to work.

------
michaelmior
I have a repository[0] that holds all my configuration and installs some
language-specific tools. Otherwise I just manually install any packages I
need. I may consider automating this at some point but I don't use that many
tools so it hasn't been particularly onerous.

[0]
[https://github.com/michaelmior/dotfiles](https://github.com/michaelmior/dotfiles)

~~~
masukomi
ditto. In addition to dot files, my repo has a `system_setup.sh` which
installs everything that can be installed on the command line and sets up
symlinks and and and. Every time i add a new tool to my arsenal (brew install
x usually) i also add it to that file. This repo means i can be up and running
on any new system in under 30 mins. Most of that time is for some manual
downloads, and git checkouts I have to do too.

------
cyptus
[https://chocolatey.org/](https://chocolatey.org/)

~~~
cyptus
windows 10 comes with packet manager, so you can just execute the following
statements on an fresh windows install (powershell):

[http://pastebin.com/HmiqDDbi](http://pastebin.com/HmiqDDbi)

~~~
sakopov
Interesting. This looks like NuGet on steroids.

------
tracker1
Depends on the system.. for OSX, first VSCode, second Homebrew, after that VS
Code. I use Homebrew to install the version-switchers for my language of
choice (usually node/nvm).

From there, I'll setup a ~/bin directory with various scripts as utilitarian.
I may source some of them in my profile script.

\----

Windows Git for Windows, Git Extensions, ConEmu, Visual Studio (Pro or
Community, depending on environment), VS Code. I should look into chocolatey,
but admit I haven't. NVM for windows.

\----

Linux/Ubuntu generally apt, and ppa's as needed.

\----

FYI: I keep my ~/bin symlinked under dropbox, as I tend to use the same
scripts in multiple places. I will separate ~/bin/win, ~/bin/osx and
~/bin/bash, and have them in the path in appropriate order... linux/bash being
default. I'll usually use bash in windows these days too, and set my OSX pref
to bash. It's the most consistent option for me, even with windows /c/...

------
rcconf
I use Ansible with Brew and Brew Cask. I've found using Brew for everything
makes it easier to upgrade all applications for security reasons and it also
gives a high level view of my system. Here's the relevant config file of the
things I install:

[https://github.com/arianitu/setup-my-
environment/blob/master...](https://github.com/arianitu/setup-my-
environment/blob/master/roles/common/vars/main.yml)

The ansible script also links to my dotfiles, which can be found at:

[https://github.com/arianitu/dotfiles](https://github.com/arianitu/dotfiles)

~~~
n42
I use a similar setup and find it quite dependable. I notice your bootstrap
script does not automate the XCode installation. Here's how you can automate
that in case you're curious: [https://github.com/timsutton/osx-vm-
templates/blob/ce8df8a74...](https://github.com/timsutton/osx-vm-
templates/blob/ce8df8a7468faa7c5312444ece1b977c1b2f77a4/scripts/xcode-cli-
tools.sh)

------
tlrobinson
I find I end up with a lot of cruft and my tools of choice change over time,
so I don't worry about it. A decent package manager makes this approach
tolerable.

Homebrew and Homebrew Cask on OS X handle at least 90% of what I want to
install.

------
HugoDias
As a rails developer, I've used and recommended
[https://github.com/thoughtbot/laptop](https://github.com/thoughtbot/laptop)
:)

~~~
gboone42
We've adapted this at 18F. It's not a fork but it is based on and inspired by
Thoughtbot's original project. Strong recommend.
[https://github.com/18f/laptop](https://github.com/18f/laptop)

------
beagle3
Not directly related, but this seems like the right thread to ask: I've been
trying to move from Linux to OS recently, and the one thing I can't stand is
the .DS_Store and other files which OSX just throws all over the place, in
every directory whether local, network or external drive.

Is there a way to stop it? (installable on a fresh system? I've been
experimenting with reformatting, so that's not a problem)

~~~
smnscu
This might have what you're looking for, anyway it's a good starting point for
a lot of commands to customize an OS X instance.
[https://github.com/mathiasbynens/dotfiles](https://github.com/mathiasbynens/dotfiles)

Edit: AFAIK .DS_Store is only created when you use Finder. In the past couple
of years I've only used the Finders to drag'n drop stuff between ~/Desktop and
~/Downloads, terminal for the rest, so .DS_Store files might not be a problem
in practice.

Edit2: Google helps answer your original question
[http://stackoverflow.com/questions/18015978/how-to-stop-
crea...](http://stackoverflow.com/questions/18015978/how-to-stop-creating-ds-
store-on-mac)

~~~
beagle3
Thanks. I was aware of asepsis, not aware of DeathToDSStore, but neither works
on El Capitan unless you turn off SIP.

I find it so surprising that there's no way to disable this.

------
cgdub
I use the Nix package manager. I use it on both Linux and OSX.

Setting up tools is quick and easy:

1\. Install Nix

2\. Copy my config to ~/.nixpkgs/config.nix

3\. Run "nix-env -i all"

------
devonkim
I've been using
[https://github.com/superlumic/superlumic](https://github.com/superlumic/superlumic)
for setting up my Mac machines because it supports a few more constructs that
are common for Macs such as plist file modifications. Since it's Ansible-based
you use YAML files to configure everything and it works well with Homebrew at
least. I spend enough time working on configuration management professionally
and don't want to spend any more time than I must to keep sinking time into my
workstation's configuration than I have to, so more complicated DSLs / systems
like Puppet, Chef, Salt are out for me despite working with those
professionally.

In the future I'd like to try NixOS for managing OS X but it seems rather
immature at this point for people that want stuff to Just Work primarily.

------
xemdetia
I usually develop in VM's where the machines are very well defined so it's
easier to build a build machine. In the end though this usually means that the
absolute package requirements are held by the project repo so what needs to be
installed is based on that.

So if I need to start a project or rebuild a system to do a project I can
generally use the project itself as guidance on what to install. After two or
three builds I have usually cleared all the dependency hurtles. The only thing
that really breaks down is not having your dotfiles available, but for me
those are backed up/in SCM.

If you are familiar with building projects from scratch it becomes a lot
easier to understand dependencies and grow the system to what it needs to be,
and with VMs it is that much easier to start with a blank slate that you are
capable of blowing away and not even trouble secondary workflows.

------
CraigJPerry
I did do ansible [https://github.com/CraigJPerry/home-
network](https://github.com/CraigJPerry/home-network) but I've decided it's
overkill for my dev machines.

I still like ansible as a layer on top of AMI images when I spin projects up
in the cloud though. I don't want to have to go install iotop when I want to
use it, I want to just know that my tools are present and ready to go. But I
consider this a different type of machine from my dev hosts.

As I see it, the best solution on a dev machine is to make it easy to install
software I might need in future. That means having a package manager available
and access to my preferred configuration. On linux I just need my dotfiles
repo available on the box, on windows I also need chocolatey installed.

------
USAnum1
I keep a series of basic setup scripts for Ubuntu on my github[0]. I do wget
and pipe them to bash, which I'm not tremendously proud of...

[0]: [https://github.com/cjjeakle/devbox-
setup](https://github.com/cjjeakle/devbox-setup)

------
StillBored
I use bash+rpm.

RPM's are insanely easy to create, and the work helps with deployment/version
tracking on the end machine. For example I have an .spec that downloads a
given version of codeIgniter, unzips it, tweaks some permissions, and then
rolls it into an RPM and tosses it into a network accessible repo. The RPM has
a pretty complete list of dependencies, so they automatically get pulled in.

So my devel script looks something like:

    
    
      cat <<EOF
      "EOF" > /etc/yum.repos.d/local-repo.repo
      [local-repo]
      name=local-repo
      baseurl=http://xxxx
      enabled=1
      gpgcheck=...
      EOF
    
      PACKAGES="codeigniter otherstuff"
    
      for PKG in $PACKAGES; do
       sudo yum install -y $PKG;
      done

------
antjanus
A few days old but I wanted to contribute anyways:

I do a really fresh/clean install. I install tools as I need them and find
myself leaving tools behind often and trying things out. I get setup on new
machines pretty often: whether I installed a new linux distro on my
chromebook, finally dual-booting Linux on my PC, or just setting up a dev VM.

Anyways, I recently abandoned using Tmux because I prefer using i3 as my
window manager and it works for me much better because now I can not only tile
terminal windows but also other utilities.

I've also moved on from using CMDer straight to using ConEmu on my Windows
machine. Every reinstall is basically doing inventory of my tools.

Obviously, I keep a repo of dotfiles and other settings files.

------
zwetan
Not as Bash script but some time ago I documented complete environment setup
for Windows / Mac OS X / Linux

[https://github.com/Corsaair/redtamarin/wiki/DeveloperEnviron...](https://github.com/Corsaair/redtamarin/wiki/DeveloperEnvironment)

The Windows part have a Batch script setup to automate the install of cygwin,
apt-cyg, wpkg, etc.

It is very specific to the Redtamarin project, compiling C++, compiling Java,
compiling AS3 to bytecode, etc.

there are also other doc for hardware setup, SSH to/from Windows, running
"remote" build from the LAN, etc.

but the setup should work for about anything, comments to improve it welcome
:)

------
smountcastle
I use
[https://github.com/denisphillips/boxible](https://github.com/denisphillips/boxible)
it's like GitHub's Boxen project but instead of Puppet it uses Ansible.

------
khedoros
At work, we support umpteen OSes in our build (a lot of C++ stuff, so it's
picky about where it builds and runs). For the Linux side of things (where
most of the dev work is actually done), I'm in the process of building Docker
images for our range of build machines, so that a developer can put up a
releng-equivalent build environment in a couple minutes, pulling images from a
locally-hosted registry.

Our current system is built on a combination of VM templates and documentation
for the devs to set up their own build machines manually. Anything that I
can't containerize will be stuck there, too.

------
Keats
I'm on Archlinux and I keep a list of the packages installed from pacman and
from AUR and some config files in
[https://github.com/Keats/dotfiles](https://github.com/Keats/dotfiles)
([https://github.com/Keats/dotfiles/blob/master/zshrc#L39-L40](https://github.com/Keats/dotfiles/blob/master/zshrc#L39-L40)
for the aliases).

I haven't reinstalled in a long time so the install script might be broken
though

------
pricechild
I maintain Ansible playbooks for my own systems should the worst happen.

~~~
ChilledHands
Just to make sure I understand, your play book isn't for a VM but a host os?

~~~
pricechild
Yep. You can use 'connection: local' for example.

------
hashhar
I think you might like this ([https://github.com/snwh/ubuntu-post-
install/](https://github.com/snwh/ubuntu-post-install/)) project a lot.

Well, personally, I made my own project somewhat similar to the one I linked
to but mine wasn't that savvy. Plus mine also installed stuff from npm
(linters mostly), ruby-gems (jekyll blog), pip and grabbed some sources and
compiled them and symlinked them to proper places using GNU Stow.

PS: He's the developer of Paper GTK Theme.

------
marcosdumay
Debian 8 has been very brittle, what gave me some experience on creating fresh
systems at home...

I have my configurations on a version controlled puppet repository. This
helped a lot, and I'd recommend anybody to forget /etc versioning, and use a
proper configuration control system even when it's not exactly a requirement.
I'm about to ditch my /etc backups now.

A certain source of pain is software that must be kept up to date. I have
Firefox and GHC on this category. Both hurt, but it's not worth it to
repackage them.

------
edcastro
I use Ansible to install all my desktop basically. This coupled with my
dotfiles (that includes a bash for gnome configuration) makes my workstation
ready in 15 minutes or so.

This is my Ansible repo for reference: [https://gitlab.com/edgard/ansible-
ubuntu](https://gitlab.com/edgard/ansible-ubuntu)

And dotfiles:
[https://gitlab.com/edgard/dotfiles](https://gitlab.com/edgard/dotfiles)

------
hacksonx
I'm one of those guys with an install.sh file that I got from my mentor. I
just run it on every new install. Last time being when I installed Ubuntu
16.04.

~~~
vmorgulis
Mine is called "apt-all.sh" and installs gcc, clang, qemu and some libraries:

[https://github.com/vmorgulys/sandbox/blob/master/stackcity/t...](https://github.com/vmorgulys/sandbox/blob/master/stackcity/tool/debian/apt-
all.sh)

It's a big list of "apt-get -y install".

------
WA
I started to use Vagrant together with
[https://puphpet.com/](https://puphpet.com/) to create a dev machine. I have a
MacBook Air and won't pollute it anymore with a dev environment. With a
virtual machine, everything stays separated in a nice and tidy way.

Installing dev tools on OS X are a matter of minutes then, because everything
else comes with the Vagrant box.

Edit: I'm a web dev guy.

------
willejs
I use Chef, Ive got a cookbook here that uses policy files to install homebrew
and homebrew casks and set up some stuff. It slao tests it in test kitchen,
converging an os x system in virtulbox! [https://github.com/willejs/chef-
workstation](https://github.com/willejs/chef-workstation)

------
schneidmaster
(OSX) I keep a bash script in a gist on GitHub that I can copy down and run on
a new system. It installes Homebrew, rvm, nvm, and then a bunch of homebrew
and homebrew-cask packages which is pretty much all of my development
environment. Every so often I'll `brew list` and paste in the latest
dependency list to keep it up to date.

------
bryanlarsen
Question: why are you doing a fresh install? If you install everything through
your package manager, you don't need a fresh install to clean things up. My
operating system has lived through several different machine upgrades. I just
do a `cp -a` to copy the files from one hard drive to another, set up the
bootloader and go.

~~~
collyw
Theoretically that may be the case, but its far from reality.

~~~
Symbiote
It's not the same hard drive, but the files in /var/log/installer/ show I
installed Ubuntu 10.10 on 24 October 2010. It's been upgraded since, and
copied to a new drive at least once.

/etc/popularity-contest.conf has the same timestamp, so I'm curious whether
Ubuntu (or Debian) keep any statistics on the lifetime of a system.

------
yasinaydin
I use Arch Linux and follow the basic guidelines for installation and modules.
The rest is synchronized with my Dropbox and I created a bash script to remove
the configuration files and symbolic link them to their respective folders in
my sync folder. Thus I can also maintain the same configuration on my other
computers, too.

------
recursive
It's about an even split between installers from an MSDN account, and a ninite
bundled installer for the rest.

~~~
lostsock
Ninite bundled installer has made setting up new computers for family members
so mindlessly easy. So glad it exists.

------
zwischenzug
I use a ShutIt script:

[https://github.com/ianmiell/shutit-home-
server/blob/master/S...](https://github.com/ianmiell/shutit-home-
server/blob/master/Shutitfile)

it's platform independent and automates the install of everything I need.

~~~
zwischenzug
More info:

[https://github.com/ianmiell/shutitfile/blob/master/README.md](https://github.com/ianmiell/shutitfile/blob/master/README.md)

[https://github.com/ianmiell/shutitfile/blob/master/CheatShee...](https://github.com/ianmiell/shutitfile/blob/master/CheatSheet.md)

[http://ianmiell.github.io/shutit/](http://ianmiell.github.io/shutit/)

------
nekgrim
I created a personal list, but half of the install is manually made:
[https://framagit.org/briced/conffiles/raw/master/INSTALL.md](https://framagit.org/briced/conffiles/raw/master/INSTALL.md)

------
ashishb
Here are mine:
[https://github.com/ashishb/dotfiles/blob/master/setup/setup_...](https://github.com/ashishb/dotfiles/blob/master/setup/setup_new_mac_machine.sh)

------
greydius

        sudo apt-get install emacs

~~~
Cthulhu_
OP asked how to install developer tools, not how to install an OS ;)

------
eropple
I have a bash script and a PowerShell script stored in a web-accessible place.
I pull it down and it bootstraps Chef to run chef-solo on the machine from a
repository stored in a trusted location.

Dotfiles are stored in Dropbox, too, which is handy for keeping zsh and
Sublime synced.

------
pathikrit
Here's my brain dead script: [https://github.com/pathikrit/mac-setup-
script/blob/master/se...](https://github.com/pathikrit/mac-setup-
script/blob/master/setup.sh)

------
thomasreggi
I'm very interested in a way to containerize (runing them within a vm) these
tools that way nothing needs to be installed, and could go easily from machine
to machine, without polluting the filesystem.

~~~
ams6110
Honestly I think this is overkill. For a dev machine, I install all my tools
locally that way "yum update" or equivalent keeps everything up to date
easily.

Use VMs or containers for local simulation of your deployment targets.

------
straws
I've had a painless time setting up my mac with
[https://github.com/msanders/cider](https://github.com/msanders/cider)

------
Kerrick
I use Thoughtbot's Laptop.
[https://github.com/thoughtbot/laptop](https://github.com/thoughtbot/laptop)

------
pfista
I tried boxen from github. Like others have mentioned, tools like these have a
big learning curve and boxen was pretty high maintenance after setup in my
experience.

------
dschep
I use ansible: [https://github.com/dschep/box](https://github.com/dschep/box)

~~~
hhandoko
Ansible is great, we use it at work extensively. But I am sticking with
Vagrant for OSS project as it (Ansible) does not work with Windows host.

------
beat
1\. Install Vagrant.

2\. Install git.

3\. Check out the complete, working development environment and run its
Vagrantfile.

------
digitalpacman
choco install as the need arises

