Micah Elliott

Clojure Annoyances

Sat, 03 Dec 2016 00:00:00 -0800

Audience: Clojure beginners

“You have to be quite heavily invested in someone to do them the honour of telling them you’re annoyed with them.” ― Alain de Botton

Every language has warts. This is not the first wart piece written on Clojure, but it’s my unique take on it. There are some workarounds, but these will bite newbies. Despite these minor annoyances, I still find Clojure to be the best environment to work in for many years to come.

Memory hogging

That’s a Raspberry Pi in his mouth. It’s being devoured.

Every time this is brought up there are arguments that Clojure and the JVM alone don’t use too much memory. But once lein is starting an nREPL for a non-trivial project, you’ll want to have a 16+ GB machine. The situation would be even worse if you use a heavy IDE (like IntelliJ or Eclipse).

I’m still sometimes clumsy with my setup, and may have a REPL going that’s not connected to Vim, plus a lein run server running. And then another for generating this blog (that one has some leak that gets it up to 5 GB after a few days!). Maybe another for testing and working through 4clojure. So if you’re not careful, you’ll want to limit yourself to running one project at a time.

All this can make Clojure a non-starter for students with minimal systems, like older Linux laptops or Raspberry Pis.

Remedies: https://github.com/technomancy/leiningen/wiki/Faster, light/smart editors

Slow startup

Clojure starts up quickly (relative to lein, anyway). But the full lein environment is taking me 17+ seconds in a default Luminus project.

Clojure itself is super fast for a lot of things…. once it’s started.

Remedies: Trampoline, Drip

Lots of parentheses

These can drive a newbie crazy. But once you learn to paredit them, they’re quite a boon for moving code around. They’re also pretty easy to auto-add and auto-balance, and even auto-color.

Remedies: paredit, sexp, rainbow parentheses

Deal with Java

Process trees cluttered with really long invocations.

This happens with a lot of other environments, too, though. I see it with Erlang when running RabbitMQ; with Rails running Passenger; with MySQL; etc.

Remedies: tree view, live with it, forget *top and use real monitoring tools

Awful backtraces

I actually don’t see these very often. I’m not sure if it’s due to clj-stacktrace being everpresent in my setup.

Remedies: small fonts, scrolling

Not always expressive

Heavy setup

In Racket

Everyone uses Emacs

…and maybe you don’t. But that’s okay. Many are also having success with Vim, LightTable, and Cursive.

You can watch guns in this video doing some cool things: https://vimeo.com/80650659https://vimeo.com/80650659

Docstrings require an extra line

Python supports this style of coding:

def fetch(dog):
    "Get dog to grab my slippers."
    dog.walk_to_bedroom() ...

In Clojure, we have to write:

(defn fetch
  "Get dog to grab my slippers."
  [dog]
  (walk-to-bedroom ...) ...)

But it would be much nicer to write:

(defn fetch [dog]
  "Get dog to grab my slippers."
  (walk-to-bedroom ...) ...)

This, of course, is due to multiple arity support, but still annoying. So I find myself resorting to:

;; Get dog to grab my slippers.
(defn fetch [dog]
  (walk-to-bedroom ...) ...)

But Clojure is still the best

The Criteria: Only three really in the race

I’ve grown persnickety after many years working with less satisfying environments, and now I value comfortable workflow above most things. This has brought me to only considering a few that have hope for joyful programming. They are Clojure, Racket, and OCaml. (Elm and LiveScript get honorable mentions as great languages.)

expressive, succinct
simple
functional (and thus parallelizable)
fast and light (Clojure almost doesn’t make the cut here)

Considerations that are secondary also, unfortunately, have strong impact:

jobs available
projects with many eyeballs
widely adopted in usage
tutorials, books, screencasts, discussions

In the end, Racket and OCaml both suffer from having communities that are too small, tools that are not widely enough adopted, projects without enough eyeballs, and tutorials not yet written. As much as I (and you) should work on addressing those shortcomings, most of us have other practical things presently pressing harder.

So that leaves us with Clojure.

(It’s not that I haven’t considered most of the up-and-coming languages that get a lot of attention. They just don’t satisfy the above constraints. So, I’m left not really considering: Scala, Elixir, Rust, Go, Haskell.)

Summary of Why Clojure Wins

(Note: shown above is vim using the “conceal” feature for functions like partition, map, apply, etc. You either love or hate this.)

Aesthetics
- code density
- beautiful rainbow parens (hooks for moving code)
- functional: map, filter, reduce
Paredit/Sexp: parentheses become hooks for moving code
Trivial parallelism (sometimes, via pmap)
Isomorphic possibilities: server (web frameworks) and client (reagent, om). You’re probably not going to be a great developer in both JavaScript and some other language on the back end (Ruby, Python, Java), so why not just be great in Clojure/Script?
Crazy REPL abilities
Many companies are invested
A better way to use Java libs
Lein is an all-in-one (cf. rails, gem, bundle, rake)
- but also boot
Many learning resources (books, podcasts, screencasts, newletters, discussions)
A simple language mostly grokkable in a day (by experienced programmers with some functional knowledge)
Many tools (plus anything from java)
Great data structures
Functional code (referentially transparent) is most testable
All the fancy big data tools are now java (spark, storm, flink, hadoop…)
Macros (there’s even a book on them)
A style guide whose perfect sensibility says a lot
A debugger inside emacs!

Why Learn a Lisp?

Sat, 10 Sep 2016 00:00:00 -0700

Programming in Lisp is a different kind of programming. Some things seem similar to your daily imperative treadmill, but mostly it’s different. There’s a different lexicon of terms, REPL-driven (or rather, -dominated) programming, there’s immutability, a really different type of (par)editing, a higher level of conciseness, a naturalness to using HoFs, a leaning on a small set of primitives, recursion as the norm, and so on.

It’s worth gaining some proficiency with a Lisp, if anything, to change the way you think about programming. In this post I explore the Lisp landscape, and try to convince you to get in on the Racket, for edification, fun, and even profit.

Lisp Engines

Lisp is embedded in a lot of places.

Despite Lua being often recognized as being The Embeddable Language, surprisingly many tools are programmable in Lisp. Some examples include: Gimp, Guix, Emacs, AutoCAD, LilyPond, GnuCash, Festival

There are several Lisps designed especially for embedding, such as Chibi-scheme, PicoLisp, TinyScheme, and Hedgehog.

BTW, I don’t discredit Vim for not having an embedded Lisp. I see most of Vim (even VimL) as a very special DSL. Even with Lisp, you just can’t get as concise as Vim commands.

Scheme learning resources

Books

Structure and Interpretation of Computer Programs(SICP)
The Little Schemer (TLS)
Simply Scheme: Introducing CS (SSICS)
How to Design Programs (HtDP)
The Scheme Programming Language (TSPL4)
Realm of Racket (RoR)
Programming Languages: Application and Interpretation (PLAI)

Some of those are seminal classics that can teach you how to program like almost no other book. Notice that bent towards Scheme. That’s the beauty of Racket: decades of academic knowledge still applicable to a modern language. Most of those books available for free in web form.

If you want to get into Artificial Intelligence (AI), you’ll surely spend some time in Lisp.

Web

A few invaluable web resources are:

The Racket Guide; extensive
Racket on Rosetta Code; a top language
Racket on “Learn X in Y minutes”; brief feature/language overview

Videos

Randall Schwartz intro on Twit

Lightweight

Racket installs everywhere. It has a small footprint and starts up quickly. Very modest student machines can run it without hitting any resource limits.

Although the community heavily supports their own IDE, there’s no reason you have to use it. It has some nice graphical-oriented features, but Vim and Emacs are great for editing Racket.

Decent REPL

Nice little REPL can do completion, and features a vi-mode. Works well with vim-slime.

But can you get paid to code in Lisp?

Yes. I think the most likely route right now is through Clojure. I loved my couple of years with it, but it’s a little too beastly to be promoting for student adoption.

ClojureScript (and Om/Reagent) is also sure to open up more webdev jobs.

So why learn Racket?

Successful Lisp companies/sites

Cognitect
Airstash
YouPatch (startup)
Orbitz
Flightcaster (much of it in Clojure, now acquired)

CentOS vs the Rest

Sun, 17 Jul 2016 00:00:00 -0700

I’ve been hooked on CentOS for servers for a couple years now. We used to use Ubuntu, but I see several advantages to choosing CentOS over Ubuntu and others. Here’s why:

UPDATE 2017:

Smooth updates. Since starting all our servers out on CentOS 7.0, they’ve all been cleanly upgraded to 7.3 without any fuss or ceremony. Looked like any other daily update.

Our Consultancies use CentOS. We’ve been in a couple data centers that encourage using their supported platforms based on CentOS. We also work with a MySQL team that knows and prefers CentOS to any other.

CentOS (and Fedora) have had Systemd in production releases for over a year. This is probably the biggest reason. Ubuntu is getting it eventually, but CentOS has had it and it’s working well. You’ll have to adopt it with Linux anyway, so why not now?

CentOS is a first-class member of a strong Red Hat family. They were recently acquired by Red Hat and now benefit from lots of company resources.

Vendors will install CentOS for you. It was EC2’s default OS for a while (still?), and is found widely available on other VPSs.

More hardware is certified for Red Hat.

CentOS releases are good for 10 years. If you were totally stuck with not being able to upgrade a system, this makes for a pretty good life span. Ubuntu LTSs are only 5 years. :) So, minor win.

Fedora is a well-tested cutting edge distro and CentOS get the best of its learnings. It’s solid as a desktop, so you can use it for development and have a pretty consistent environment across your desk and servers.

Red Hat/CentOS have a well-defined focus. They embrace the fact that they are a server OS. Compare this to Ubuntu’s focus on touch interfaces, display managers, phones.

There are certifications for becoming a (so-called) Red Hat expert.

There is an upgrade path to RHEL if someone insists upon it. Some PHBs will want to know that they can throw money around to buy “guarantees” about stability/support.

CentOS is ubiquitous. Most cloud VPSs will offer it as an option.

Docker is in production. I don’t think Docker is a panacea, but it’s good to see it’s being well tested in RHEL and CentOS.

Firewalld is new and in. It’s not terribly well documented, but it’s really just a front end to iptables.

EPEL provides many extra packages.

Docker is a major focus of Red Hat.

SELinux is more powerful than AppArmor. Though there is a bigger learning curve. See this comparison.

Arch is very similar. Arch is a popular and powerful development Linux OS. It’s cutting edge, and the AUR is the easiest way to quickly install the widest variety of tools. Hopping onto a CentOS server from the comforts of your Arch setup is not much of a leap. Generally, you’ll find the same standard tools on both.

Shortcomings

Not everything is perfect with CentOS, though. It does not always have the newest versions of packages you might desire. I end up building my own versions of Nginx, Redis, Ruby, and others.

The security update story is also a bit lacking. The simplest way I have found to stay up-to-date on vulnerability patching is to watch the daily mail list, and email myself every time a server sees available updates (yum-cron). Then I can use Ansible to update the fleet, and check if any updates will require reboots, though they’re rarely needed: a few per year, when kernels or glibc updates.

Yum is the package manager and it is in flux, and essentially pronounced dead. Fortunately, dnf appears to have some backward compatibility with yum and should provide a clean transition.

If you’re looking for a broader spectrum of OSs to choose from, particularly for your desktop, read my article on choosing an OS.

Who Uses Emacs?

Tue, 26 Apr 2016 00:00:00 -0700

It has been a difficult decision to consider moving to Emacs. Besides discovering that it had some superpowers that Vim lacked, I had a niggling feeling that most of my programming heroes were already using Emacs. So I did some digging around to see who were the luminaries.

The digging turned up that the following all use Emacs. (Sorry for not recording many references.)

Language Creators

Rich Hickey (Clojure creator)
Joe Armstrong (Erlang creator)
Xavier Leroy (OCaml creator)
Matz (Ruby creator)
Guido van Rossum (GvR, Python creator)
Donald Knuth (TeX, Algo books)
Michael Widenius (MySQL creator)
Guy Steele (creator of many languages)
James Gosling (Java creator)
Peter Norvig

Miscellaneous Celebrities

Eric Raymond (ESR)
Richard Stallman (RMS)
Jamie Zawinsky (JWZ)
Linux Torvalds (Creator of Linux, uses micro-emacs)
Neal Stephenson (author)
Steve Yegge
Avdi Grimm (and other Ruby Rogues)
Vernor Vinge

More mentioned: Norvig, Andreesen, Guy Steele, Martin Fowler, Knuth, Julian Assange

And, 45% of Clojure devs use Emacs, accoring to the recent survey.

Who (surprisingly) does not use Emacs

Paul Graham (lisp hacker) — vim

Larry Wall — vim

Rob Pike — acme

Brendan Eich — vim

The Outage Log

Wed, 10 Feb 2016 00:00:00 -0800

Audience: sysadmins

“A captain of a ship, no matter his rank, must follow the book.” —Captain James T. Kirk

I’ve been keeping an "Outages Log" for the last few years to track downtime and causes of failures (sometimes they’re only theories). This has turned out to be an invaluable record, so I’ll share the idea here and encourage you to keep one, too.

The OutagesLog is maintained as a wiki page. It’s helpful is spotting problem patterns, and identifies when something has been neglected. The goal is to never have the same problem twice.

The front-matter is a brainstorm/laundry list of things that can go (or have gone) wrong.

Cloudflare hiccups
Data center network
Failing critical batch job
Hardware
App bugs (looping retries)
DB swap/backup problem
Forgetting to restart passengers on deploy
DNS confusion/loss
Bad upgrade rotation

A list of symptoms of each is also helpful.

Depending on the number of machines you’re managing, it might be feasible to also track system updates and reboots here. Hopefully these are done on a consistent schedule across most machines.

Here is an example set of entries. The entries are organized by year. Each entry contains a date-time-stamp with the number of minutes down/impacted, followed by diagnosis. A more detailed reporting would also contain a link to a fuller description of the outage and planned remedies.

2014
[Jan 13 18:14] 18m: db network failure; VIP disappeared (link to full report)
[Feb 06 22:44] 2m: Two hiccups. DC acknowledged router issue on their end
[Feb 28 12:24] 3h: Wow, DC breaker trip, fries dbs91 controller. Recovery takes many hours before discovering disk will be too slow. Eventual reboots help, but we have to fail over to Houston.

Bare Metal vs The Cloud

Wed, 20 Jan 2016 00:00:00 -0800

Audience: devops

Only you can decide if the cloud is flipping you the bird.

Most of us start our fledgling apps in the cloud, on EC2 or Linode or DigitalOcean or ASmallOrange or whatever. With Membean, we’ve bounced around on all of those. But we eventually ended up in real data centers, for a lot of reasons.

TL;DR

I’ve had servers spread around several VPS providers for the last eight years. The last four years have been mostly colocated on hardware I’ve purchased, and that HW has served us well. Granted, a lot of my time (and thus salary) is spent on taking care of machines, but it’s not much more (if any) than we’d be spending if we had stuck fully to the cloud. I think it’s a lot less.

Cases for the VPS Cloud

You’ll need multiple servers before long, for scale and redundancy. So, early on, two little VPSs are much cheaper than two physical servers.
It’s really easy to create nodes through a web UI.
Don’t need to know much about data centers.
In some cases, theoretically cheaper if you spin down servers, and your off-peak hours are long. I believe the spin-down-to-save model is unique to EC2. A Droplet incurs the same price whether running or powered off.
Backups are simple. Just check a box when you create your Droplet, and you’re probably safe enough.

War Stories (Beware the Cloud)

Linode was down for days.

I have seen more than a few emails from DO and Linode saying that a node has been rebooted due to an unknown issue. If these had been production systems, OUCH!

There are times where CPU has spiked for no apparent reason.

CPU availability may be unpredictable.

VMWare Lock-in

I’ve stayed away from virtualization, particularly proprietary offerings. Running servers is expensive enough as it is.

I don’t see what the big gains are from virtualization for SMBs. If hardware is going to fail, it’ll wipe out the whole machine and all its virtualized nodes.

It’s yet another thing to understand and monitor. Plus, there are potentially some performance costs.

Cost

I’m not convinced that paying 10x for a RHEL licensed Megacorp Certified System gets you much more than a more standard off-brand setup.

You can find beefy servers for as low as $1500.

Performance

Latency

Nodes won’t be right next to each other. Maybe there are tactics to control this, but I haven’t found many yet.

Risks

DDoS is always a concern, whether Cloud or Data Center. After moving to a DC, we got hit hard enough by a DDoS that it took down the whole data center. That was the worst outage we’ve had, and resulted in 8 hours of downtime. We never found out why we were targeted, but learned some good lessons from it.

I actually think we’re less likely to be impacted by DDoS in a DC. It seems to be the bigger players, like Linode and Amazon who get targeted. I hope DO is prepared for what happened to Linode. The DCs we’ve been in have few high-profile customers in them. So a whole network outage seems less likely.

Common Objections

“The cloud gives me snapshots so I can just build up one server and then duplicate them from the single good snapshot.”

You’ll still want to get your setup into a configuration management system, like Ansible or Chef or Puppet.

“The cloud takes care of monitoring for me.”

You’ll still need to come up with monitoring solutions, like monit, monitorix, nagios, etc.

“I’m not comfortable running servers myself.”

That’s a valid concern, but you need to learn a lot about them anyway, even if you’re in the cloud. The cloud does kind of save you from dealing with HW failures, but the still certainly happen in the cloud.

And, failures are often not something you have to handle all on your own. The DC folks are very knowledgable about networking issues, and swapping out failed disks is something they do a lot of.

“But I don’t live anywhere near a good data center.”

We started out in a nearby DC thinking that we’d want to get inside when horror struck. That lasted a year before we looked outside to find a better DC thousands of miles away. It’s possible to do everything remotely. Remote hands are pretty cheap, usually around $25/hr.

I’ve had them replace disks, rebuild machines, install OSs, reconfigure RAIDs, figure out my network blunderings, and much more.

They’ve even tuned network routes so that our cross-DC transfers are much improved.

Downsides

How to Structure a .zshrc

Sat, 16 Jan 2016 00:00:00 -0800

Audience: intermediate

I often recommend that people “stick this-or-that in their .zshrc.” But what I really mean is to “put this-or-that into the appropriate subfile that makes up a bit of their grander Zsh configuration.” There are some great benefits to piecing apart a single monolithic .zshrc file into individual files.

At the top level, you still have your ~/.zshrc, but it’s mostly just responsible for `source`ing the meatier files.

It looks something like:

# Some envars
my_fname=micah
my_shdir=~/config/shell
my_configs=(
    envars.sh
    actions.sh  # super fast
    options.zsh # potential to be slow
    aliases.sh
    aliases.zsh
    functions.sh
)
my_plugins=( $my_shdir/zsh/plugins/*.zsh )

# Time the stuff.
integer t0=$(date '+%s')

# Source all the Zsh-specific and sh-generic files.
for f in $my_configs; do
    ##print starting $f
    [[ -f $my_shdir/$f ]] && . $my_shdir/$f
    ##print finished $f
done

# Plugin stuff omitted
# Site-specific stuff omitted

function {
    local -i t1 startup
    t1=$(date '+%s')
    startup=$(( t1 - t0 ))
    [[ $startup -gt 1 ]] && print "Hmm, poor shell startup time: $startup"
    ##print "startup time: $startup"
}
unset t0

This is helpful in that it:

keeps things well organized
enables reloading of any particular piece

The key commands I use to change, say, a single alias or function in a config file are aliases themselves:

alias re-env=". $my_shdir/envars.sh"
alias re-funcs=". $my_shdir/functions.sh"
re-aliases() { . $my_shdir/aliases.sh; . $my_shdir/aliases.zsh }
alias re-opts=". $my_shdir/options.zsh"

# Bonus
alias a=alias
alias fn='declare -f'

If you are simply re-source-ing a giant .zshrc, you’re possibly overriding or double-setting environment variables, or undoing setting you’ve made manually in your shell session.

I recommend you come up with your own, mostly from scratch, but here’s mine if you’re curious.

This StackOverflow answer has more details about how to profile your shell start-up time.

The 14-Digit Timestamp, et al

Thu, 14 Jan 2016 00:00:00 -0800

Audience: anyone

The so-called “14-digit timestamp” is turning up in more and more places. For those unfamiliar, it takes the form of:

YYYYMMDDhhmmss

I’ve seen it recently in Migratus and Rails/Cap deploys (current symlink), and it’s been used widely by MySQL. They’re pretty handy for setting to-the-second precision for ordering of things, like database migrations. And, they’re fairly human-parsable.

At the time of this writing, the 14-digit time is 20160114180301. If you find that hard to eye-parse, here’s a (really ugly) shell function to help:

dt14p() { sed -r 's/([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})/\1-\2-\3 \4:\5:\6/' <<< $1 }

% dt14p 20160114184117
2016-01-14 18:41:17

This enables date (and your eyes) to parse it.

Something I see missed on occasion is the use of UTC on such stamps. That seems pretty important if you’re using these for ordering, and have a time zone-distributed team.

14s are not to be confused with the 10-digit epoch-second-stamp, or MongoDB’s similar 64-bit 13-digit stamp (1452758412345).

You might also find weekstamps useful for writing weekly reports and other organization.

Generating a 14-digit stamp

date --utc +%Y%m%d%H%M%S

Why not make it an alias?

alias dt14='date --utc +%Y%m%d%H%M%S'

And use it often:

mkdir `dt14`-something

(I usually find the 8-digit datestamp dt8 to be sufficient for directory names.)

While we’re at it, here are some other useful stamping aliases. I use the dt prefix to make them easy to both remember and tab-complete. Some of these I use every day. Put them in your .zshrc and enjoy!

alias dt='date +%Y%m%d'    # frequent 8-digit stamp: 20160114
alias dt8=dt
alias day=dt
alias dts='date +%s'       # seconds since epoch: 1452795263
alias dte=dts
alias dt10=dts
alias dtep='print "use this to parse: date -d @123..."'  # parse the epoch
alias dtp='date -d '       # parse
alias dttm='date --utc +%Y%m%d%H%M%S'  # datetime: 20160114192940
alias dt14=dttm
alias dt13=dtb
alias dto='date +%Y%j'     # ordinal date: 2016016 (16th day of year)
alias dt7=dto
# https://en.wikipedia.org/wiki/ISO_week_date
alias dtwk='date +W%V'     # week date: W02
alias dtyrwk='date +%GW%V' # year week date: 2016W02
# ISO 8601
alias dtw='date +%G-W%V-%' # year week: 2016-W02-4
alias dti='date -I'        # ISO-8601: 2016-01-14
alias dt-=dti
alias dti='date -u +%Y%m%dT%H%M%S'        # 20160111T173110Z
alias dti-='date -u +%Y-%m-%dT%H:%M:%SZ'  # 2016-01-11T17:31:10Z
alias dti0='date -u -Iseconds'            # 2016-01-11T17:31:10+0000
alias dto-='date +%Y-%j'                  # ordinal date: 2016-016
alias dtb="date-iso2bson.rb <<<\"'`dt-`'\""  # for mongo bson

(Note: this is using date from GNU Coreutils. Yours may be different if you’re not on Linux.)

Choosing your Everyday Operating System

Sun, 10 Jan 2016 00:00:00 -0800

A wise person on some podcast I once heard said something like …

Linux is a PC OS ported to UNIX, BSD is a UNIX ported to the PC.

Three great operating systems are recommended for growing your programming chops: Arch Linux, Gentoo Linux, and FreeBSD/PC-BSD.

You’re welcome to go with a more mainstream UNIX like Ubuntu or OSX, but these have a tendency to hide lower level OS details; you’ll learn a lot more by choosing one of our recommendations. Your preference for control, speed, licensing, and mainstreamedness will determine your choice. All three are bleeding edge rolling release, highly open, fast, minimalist, configurable via text files, and security conscious. And all have uniquely fantastic package managers.

Linux or BSD?

The first consideration is what license model appeals to you. Linux is GPL (v2), which means that many of the tools you’ll use are going to be GPL, and changes that you make to code should be shared back with the community. BSD’s stance on licensing is that you can do whatever you want with changing of code. For some business cases this may be a preferable model. You may not be augmenting your system tools or kernel, but some day you very well may.

Linux is more popular than BSD, but that doesn’t mean it’s better. BSD powers much of the internet today, including sites like Netflix and Yahoo. It’s even what’s underneath OSX.

Linux has broader reach, particularly in mobile and embedded computing. It’s what powers your Android phone. It’s in your router, and probably even in your microwave. There are literally hundreds of distributions out there that you could install on your laptop right now, many of which are in widespread use in data centers and as desktops.

When you start up your shiny new service on an affordable VPS, most of your options are going to be Linux based. Popular VPS hosting services include Linode, DigitalOcean, and Rackspace, all of which primarily offer Linux (and only Linux). There are BSD hosts out there, but the paucity is something to keep in mind. If you have some idea of what OS you’ll want to eventually host your apps on, you probably want to choose that OS as what you’ll run for your home/development systems. IOW, if you decide to go with a Mac (or PC-BSD) for your daily development, you may want to go with FreeBSD in the cloud. Otherwise, choose a Linux family for both.

Linuxes nowadays are mostly based on systemd. This gives you sophisticated control of running services, fancy journaling/logging, and super-fast booting. BSDs have a simpler init startup system (but sometimes simple is a feature).

Arch Linux

The first Linux option is Arch. It is the most popular of our three and features several niceties:

Fast installation
Wikis and forums for any topic under the sun
Binary packages for speed of install
A lot of adoption momentum

Gentoo Linux

Gentoo is a DIY OS. You build everything yourself to suit the architectural details of your system; you even configure and build your own kernel! It takes some time to build/install a Gentoo, but the result and learning experience is usually worth it. Compelling features:

System is tuned to be fast!
Ultimate control of every tool
Portage/emerge

Fedora Linux

The main advantage to using fedora is that it’s in the RedHat family. The most commonly deployed server OS these days is CentOS (also based on RedHat). Read why I like CentOS to see why I this is a good choice.

PC-BSD

FreeBSD is by far the most popular of the BSDs. The experience is pretty similar to Gentoo, in that you can build most things yourself. It has some very compelling features:

ZFS (compression, reliability, raid, speed, ease of use)
Disk encryption
DTrace
All-in-one OS, maintaining the kernel and userland together
Reputation for robust security
A PC-BSD super-distro with easy installation, making laptop and server consistent

Great, you can make a choice now! It won’t be final, but it will get you on your way with your first machine of many in your lucrative career.

CentOS 7 Networking Tools

Tue, 05 Jan 2016 00:00:00 -0800

Audience: sysadmins

“Networking is an essential part of building wealth.” — Armstrong Williams

The networking toolchain is a bit different on every OS. I’ve been spending enough time on CentOS 7 lately that its specifics are worth recording.

I’ll assume you don’t care about OSs that deviate much from RH-derived. I’m also leaving out anything to do with IPv6.

Wireless networking is not something you do much on servers, so it (iw) is mostly omitted, too.

Packages

iproute2

Commands

The ip command has replaced some of the trusty old guard. If you use Zsh, the ip tab-completion is excellent for quickly using various subcommands.

wolfram cidr

ethtool

ip a

ip link

ifconfig

ifstat

ifup/ifdown

nmcli/nmtui

nmcli d s

NetworkManager (need it for firewalld)

sys

netstat -tulpn
netstat -pn tcp
netstat -ln4
netstat -naf inet

ss (socket stat)

netcat

arp

route

iotop

iostat

iperf3

host

whois/dig

ping

lsof -ni

tcpdump

ipcalc

ifrename

sockstack -4

Although traceroute is the old standard, the netadmins I’ve worked with tend to ask for mtr output.

mtr/tracepath

firewall-cmd

iostat -xdm 5

Files

/etc/sysconfig/network-scripts/ifcfg-e*
/etc/services
/etc/resolv.conf

Normal Things

pinging local Gb network: 0.15 ms

Antiquated/Deprecated

https://dougvitale.wordpress.com/2011/12/21/deprecated-linux-networking-commands-and-their-replacements/

arp
iptunnel
iwconfig
nameif
netstat
route
ifconfig
traceroute
tcpdump

yum install net-tools (last release 2001 https://lists.debian.org/debian-devel/2009/03/msg00780.html)

Glossary

uplink: incoming network drop
layers (physical, datalink, network, transport, app)
tcp/ip
nat
private addresses: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 https://en.wikipedia.org/wiki/Private_network
arp/mac address
cidr
lan
vlan (multi-homing)
netmask
broadcast
gateway
icmp
mtu
ttl
snmp: simple network management protocol
cat5e: the only cable you probably want to use

Resources

This could become a short ebook: DevOps Practical Guide to Modern Linux Networking

No More Holding Down Keys

Tue, 22 Dec 2015 00:00:00 -0800

Audience: button holders

“The chains of habit are too weak to be felt until they are too strong to be broken.” ― Samuel Johnson

I’m trying an experiment where I’ve turned my keyboard repeat rate way down. This should force me to never hold down a key for repetition, but rather use a prefix like 4w (vim) or Ctrl-Backspace (browsers). I’m learning some interesting things!

This is done easily across X with:

#              msdelay rate
#exec xset r rate 250    60    # super fast keyboard cursor delay and rate!
exec xset r rate 250    2     # super slow (vim training)

More details here.

That line is from my ~/.i3/config. Remove the exec to put in in ~/.xinitrc or the CLI.

Other Experiments

Reverse your :; key
Turn on your awful beep

Programming Heroes

Thu, 15 Oct 2015 00:00:00 -0700

Audience: anyone

“To be a hero, you have to learn to be a deviant, because you’re always going against the conformity of the group. Heroes are ordinary people whose social actions are extraordinary. Who act.” — Philip Zimbardo

The question of “who is your programming hero” comes up on episodes of [The Changelog], and it’s a good one. I have no means or aspirations to be asked, but it’s a fun question to answer, so here are my programming heroes…

John McCarthy (1927-2011)

For conceiving of Lisp.

Gerald Sussman

For co-creating Scheme and making lisp more accessible to students through his development, writing, and lecturing.

Richard Stallman (1953-)

For GNU tools, Emacs, and indefatigable promotion of open source. And for being the one to really make us think different. https://stallman.org/

Bram Moolenaar (1961-)

for Vim. https://en.wikipedia.org/wiki/Bram_Moolenaar

Linus Torvalds (1969-)

https://en.wikipedia.org/wiki/Linus_Torvalds Linux and Git. Jeez.

Edgar Codd (1923-2003)

For his relational model which led to SQL.

Robin Milner (1934-2010)

Robin Milner created ML, and ran with the ideas of type inference.

Steven Kleene (1909-1994)

For basically inventing the regex. https://en.wikipedia.org/wiki/Stephen_Cole_Kleene

Ken Thompson

For putting the regex into practical use in editors. And for co-inventing UNIX.

Honorable mentions

Rich Hickey

My first year with Clojure (2012) — which was created by Rich — opened my eyes to the beauty of lisp.

After spending some more recent time with Racket, I believe Clojure is not a panacea. Racket is beautiful for its simplicity and regularity. It also doesn’t suffer from the bloat associated with sitting on top of the JVM.

Paul Graham

Insights such as patterns being smells, the glory of Pride and Prejudice

John Backus

for his work on language specification (BNF). And for his contributions to functional programming.

Ronald Rivest

For voluminous contributions to literature on algorithms, and for giving us the security that we have today.

Paul Falstad

For creating Zsh, the shell that is both featureful and fast.

George Boole

For having managed to get his name and logic into every programming language.

Haskell Curry

For getting his name and ideas into almost as many languages and Boole. https://en.wikipedia.org/wiki/Haskell_Curry

George Zahariev, David Nolen, Evan Czaplicki

For their continued efforts to make JavaScript sane via LiveScript, ClojureScript, and Elm, respectively.

On anti-heroes

I don’t think it’s productive to name names here, so use your imagination.

Despite the efforts of the heroes I’ve listed, many have come and been seen as heroes to the masses, and yet they often worked against the real heroes. Let us eschew the “heroics” of those who have pushed languages, operating systems, and tools in directions that have done harm. Some were great experiments, and much was learned, but they have errantly gone mainstream. I’m speaking of languages where everything is an object, mutability is the norm, parallelism nears impossibility, functions are not first-class, state and behavior are conflated, and where we tell the machines how to do things instead of what to do. Of opaque systems where we have no way to know what they’re doing on our behalves. Of tools that lock us into perpetual agreements and eventual compromises and pain.

Resources

Winners of the Turing Award

AUR Getting Started Guide

Tue, 01 Sep 2015 00:00:00 -0700

Audience: intermediate

There are many options to access Arch’s User Repository (AUR). The AUR is one of the most compelling features of Arch Linux. I’ll walk you through the simplest path to getting started with the AUR, with minimal bootstrapping effort.

The most primitive yet useful tool I’ve found for first accessing the AUR is cower. On the right side of that page you’ll see a link to “Download snapshot”. It’s https://aur.archlinux.org/cgit/aur.git/snapshot/cower.tar.gz

Grab/extract/install it with:

cd $TMPDIR
wget https://aur.archlinux.org/cgit/aur.git/snapshot/cower.tar.gz
tar xzvf cower.tar.gz
cd cower
makepkg -si

You could continue to search the AUR website for packages to install, and continue to run wget/tar/cur/makepkg on them. But AUR managers make life much better than that. And now with cower (and soon more) you have full command-line access to the AUR!

Let’s search for a more featureful AUR manager. cower is cool. You can use it directly, and it’s the simple base command underlying a few of the other managers. It’s also a good tool for learning about the low-level details of the AUR (now right now). But we’ll prefer those managers that conform to pacman’s option syntax.

cower -s aurget
cower -s pacaur
cower -s yaourt

These also all happen to support nice Zsh completions.

Let’s find and install something useful. Here is the list of packages, sorted by popularity. You’ll notice yaourt is at the top. Interesting. Install archey

aurget -S --noconfirm --noedit archey

Lisp Jargon

Sun, 30 Aug 2015 00:00:00 -0700

Lisp Jargon

— http://www.lispworks.com/documentation/lw51/CLHS/Body/26_glo_b.htm

The following is a glossary of fundamental lisp terms that may be somewhat foreign to someone who is not versed in a lisp. I have cherry-picked the terms that I find to be most productive.

They are intentionally not alphabetical, but are ordered and grouped into logical sections.

sexp: s-expression, symbolic expression
statement: nothing — everything is an expression
expression
form: (vim)
string: (vim)
element: like atom (vim)
redex: reducible expression
regex(p): regular expression
lisp: list processor
list: ()
sequence
singleton: a sequence with only one element
pair
rpn: reverse polish notation: operator first
quoting
boolean
homoiconic: code is data
scheme: academic lisp dialect
racket: another scheme implementation
clojure: modern lisp on java/javascript
clisp: common lisp; old, robust lisp dialect/implementation
repl: read, eval, print, loop
emacs: most common way to edit lisp
vim: another powerful editor
slime: an editor mode that enables immediate transfer of forms from editor to repl
tree: leaves, nodes
recursion
iteration
loop
tco: tail call optimization for recursive functions
lexical (scoping): referring to scope of visibility, done through textual analysis
formal parameter
actual argument
splice
slurp
barf
name: an identifier bound to an object
object: any lisp datum
atom
identifier: a symbol used to identify names
variable
symbol
value: the result of an evaluation
reference: refer to an object or binding by name
binding: association between a name and its value (e.g., “let-binding”)
literal
keyword
vector
hash table: mapping of keys to values
macro
reader
eval
immutable
concurrency
parallelism
primitive/built-in: ex: car, cdr, cond, cons, map, null?, add1, sub1
null
map
apply
rest list: cdr
operator/operand
predicate
lambda
function
procedure
application
continuation
signature: descirption of the parameters of a method
block
begin/do
implicit block: if has these
currying
closure
hof: higher-order function, passed in to another func or returned
declaration
definition
htdp
tls
sicp
ror
exception
environment: set of bindings
package: bundle of reusable, installable code
rank: number of dimensions of an array
R5RS: revision 5 report on scheme
fingernail clippings and oatmeal
lambda calculus
srfi: scheme requests for implementation; see the SRFI FAQs

(The definitions herein are mostly my own, but much of what I know is inevitably copied from others.)

Firewalld Best Practices

Thu, 27 Aug 2015 00:00:00 -0700

Audience: sysadmins

Firewalld is the replacement for iptables in RedHat-family distros. Like it or not, you’ll probably end up having to wrestle with it at some point. I’ve read several articles describing it with an overview, but most miss out on important subtleties of a tool that’s in production but maybe not friendly enough for prime time. Here you’ll find my guide to getting the most out of Firewalld and avoiding its gotchas.

The commands get long, long, and very long to type frequently. What’s worse is that it seems you usually need to repeat them with a --permanent option, which is painful and easy to forget.

Command line completion

There appears to be a bash completer. I haven’t tried it since I’m fully in Zsh land these days for all activities. It’s not any RH repo I’m aware of anyway, so let’s forget it.

Firewalld supports a poor man’s version of completion. Instead of typing --zone, you can just type --zo or even --z. You’d have to memorize how much of each option is unambiguous. So you still have to type --list-all-z to get --list-all-zones.

So aliases are the way to go.

I did write a Zsh completer here, if you want to use it.

Ansible support

TLDR: don’t bother with Ansible for Firewalld. Even if you do, you’ll likely need to experiment with firewall-cmd to get your rules right.

Ansible’s new version 2 purports to support most of the full set of options, including --source, which I use frequently. Unfortunately, I’ve found this bleeding edge Ansible to be way too buggy to use. However, you can actually copy the newest firewalld add-on python module into Ansible v1.9. However, I don’t think it actually words, whatever version of the module your get.

Really understanding “zones”

You can actually create your own new zone:

Creating a services file

It should look like this:

<?xml version="1.0" encoding="utf-8"?>
<service>
  <short>Some Service</short>
  <description>Something very descriptive</description>
  <port port="1234" protocol="tcp"/>
  <source ip="10.1.10.10" />
</service>

Put it into /usr/lib/firewalld/services and run fwr.

Needed aliases

alias fw='firewall-cmd'
alias fwz='fw --zone'
alias fwp='fw --permanent'
alias fwr='fw --runtime-to-permanent'
alias fwpz='fw --permanent --zone'
alias fwl='fw --list-all-zones'

Gotchas

Sometimes you want to specify a source and port. But it’s not at all obvious when it’s an AND or OR specification. No one seems to mention this. But I did find this gem in the firewalld.zone man page:

The default target is {chain}_ZONE_{zone} and will be used if the target is not specified. If other than the default target is used, all settings except interface and source are ignored, because the first rule created in firewall for this zone is 'jump to target'.

To discover all the man pages, in Zsh do man firewalld«tab»

firewalld                     firewalld.lockdown-whitelist
firewalld.conf                firewalld.richlanguage
firewalld.dbus                firewalld.service
firewalld.direct              firewalld.zone
firewalld.icmptype            firewalld.zones

Vim Sexp Cheat Sheet

Thu, 20 Aug 2015 00:00:00 -0700

There are two fantastic Vim plugins that make it delightful to edit parentheses-heavy Lisp code (e.g., Racket or Clojure). I don’t know how I lived without making much use of these for years: parentheses can be terribly unwieldy.

Vim-Sexp
Sexp for Regular People, aka SRP, pronounced “Syrup”

Install them both now if you haven’t already! And read on for the cheat sheet that makes wrangling parentheses a walk in the park.

If you don’t grok Vim yet, there is surprisingly little you need to know to get started editing a Lisp with Vim. [Read this post to get started.]

Emacs users know that what appear to be a preponderance of brackets are really hooks the editor may use to effortlessly transform the text before them. — guns (author of vim-sexp)

Emacs has been the go-to environment for Lisp hackers for years. One of its particularly compelling features is “paredit”. Vim has a paredit, too, which is used as part of the SLIMV stack. I feel that SLIMV tries to do too much to your Vim, so now I’m telling you about a lighter solution: the Sexp/SRP combo.

SRP has a short README that describes all of its mappings, and it gets you most of the way to bliss. But there are a few from Sexp that are still very handy. Unlike SRP, Sexp has a lot of documentation, in both its README and vimdoc. This guide puts together the docs from both projects into a short, memorizable cheat sheet, choosing what I feel are the simplest/best set. These mostly avoid the troublesome Alt/Meta leader (which tpope doesn’t like much), and visual selection (sometimes a crutch). Where <leader> is still needed, I’ve just marked , (my leader) for brevity.

# Movement
()      move cursor to matching paren (same as % but easier) _[SEXP]_
[[ ]]   move cursor to top-level element _[SEXP]_
W B E   move cursor element/form-wise

# Indent
==      indent form  _[SEXP]_
=-      indent top level _[SEXP]_
=<movement>  indent whatever

# Move elements/forms around
>e <e     move element right/left
>f <f     move form right/left
<m- j h>  move elt left/right _[SEXP fast alternative]_ — but don’t use meta
<m- k l>  move elt left/right _[SEXP fast alternative]_ — but don’t use meta

# Slurpage and barfage
<( >)       slurp (push paren out wider)
>( <)       barf  (pull paren in narrower)
<m-s- H L>  slurp _[SEXP alternative]_ — but don’t use meta
<m-s- K J>  barf  _[SEXP alternative]_ — but don’t use meta

# Insertion, some with new parens
cse)     add surround form — easier than ysie)
<I >I    insert front/end — don’t use, too diff from ,i/,I
,h ,l    insert front/end _[SEXP]_
,i ,I    insert front/end, add surround form _[SEXP]_
,w ,W    insert front/end, add surround element _[SEXP]_

# Deletion
dsf      delete form (splice ,@)
daf dif  delete around/in form
,o       delete outer form _[SEXP]_

Note that SRP builds off of another of tpope’s concepts: Surround. That’s a good one to install and learn for any type of editing.

I struggled with these for many hours. The slurp and barf are especially hard to get your head around, so be patient. Get a simple function to experiment with, and add some extra spacing to make forms/elements stand apart. Then try out every mapping listed above.

You probably also want to install Repeat.

Also read this answer for more info on using Vim to edit Lisp.

Caveats

inline comments can get in the way
undo is funky since some commands do multiple things

Demo

Similar to the Emacs Wiki Cheat Sheet. But this is way better than Emacs’ paredit where various things are mapped to arrow keys, forcing an atrocious hand move. Oh, for shame.

You need to actually try these… a lot. But to give you an idea, see below. The ^ is where your cursor is. The is where your cursor is in _insert mode.

(aaa bbb)
        ^       (
(aaa bbb)
^

(aaa bbb)
      ^         <e
(bbb aaa)

(aaa bbb) (ccc ddd)
      ^                 >f
(ccc ddd) (aaa bbb)

((aaa bbb) ccc)
       ^                >)  slurp
((aaa bbb ccc))

((aaa bbb) ccc)
   ^                    <)  barf
((aaa) bbb ccc)

(aaa bbb) (ccc ddd)
            ^           yss)
((aaa bbb) (ccc ddd))

(aaa bbb)
      ^         <I  insert
(_ aaa bbb)
 ^

(aaa bbb)
      ^         ,i  surround and insert
(_ (aaa bbb))
 ^

(aaa bbb)
      ^         ,w  surround and insert word
(aaa (_ bbb))
      ^

(aaa (bbb ccc))
       ^        dsf
(aaa bbb ccc)

(aaa (bbb ccc))
       ^        daf
(aaa )
     ^

(aaa (bbb ccc))
       ^        ,o
(bbb ccc)
        ^

GPG Howto

Sat, 08 Aug 2015 00:00:00 -0700

Audience: anyone

Keywords: gpg security privacy encryption

❧❧❧

At one point I thought changing my name might help with privacy, but that was before the Internet. — Olivia Wilde

Have you ever told a secret to a friend? Made a transaction at your bank? Wrote an entry in your diary? Invented a secret handshake? Been to the doctor? Got a "steal" sign from your baseball coach? All of these should be private — between you and the person or thing you’re communicating with. There are two main technical standards for privacy: TLS/SSL and OpenPGP. TLS/SSL are what’s used to secure the forms you fill out on web pages, and handle secure "connections". In this episode we’ll learn all about OpenPGP, AKA Pretty Good Privacy. This is what’s used to encrypt, sign, and verify (prove who the person is) any message or file you write or read. It uses a pair of "keys" to do these jobs.

GPG is the tool we’ll focus on that implements the OpenPGP standard. It’s been around for 20+ years and is the industry standard for encrypting, signing, and verifying the contents and senders of messages and files. It’s also pretty fun to use.

The users of OpenPGP form a club of folks who want to build a "Web Of Trust" (WOT). Anyone can get in; all you need is:

A little knowledge of the gpg tool (which you’ll get here)
Some official identification for yourself
A willingness to meet people to verify their identity and sign their keys

(I hope you’re already using Zsh. If not, see previous episodes to get up to speed.)

Zsh has great command completion for gpg. Make sure you’re tab-ing all the time to auto-complete options and arguments.

Is it worth the effort/trouble?

In order to join certain mailing lists and development groups (fedora), the first thing you may be asked for is your GPG public key.

Some people you work with are going to require that your emails to them be signed.

If you develop and distribute a software package, many of your users may expect to be able to download your public key in order to verify that the software comes from you. (pacman -Qi coreutils). (https://wiki.archlinux.org/index.php/pacman-key) Though it’s more typically just a hash (MD5/SHA1).

Go get some official identification

To make any of this OpenPGP stuff legit, you’re going to need some real ID. Many kids don’t have ready access to a common ID card. But they should.

You absolutely need some sort of official ID. This could be a driver’s licence, identification card (get this from your local DMV; no age requirement), school student-body card, birth certificate/card, social security card. ([ID cards in California](http://www.dmv.ca.gov/dl/dl_info.htm#idcard))

If you don’t think you have a need for a passport, just pick up a state ID card from your DMV. It’s easy and cheap. Too many kids don’t have ID that they can readily show. So go get one.

Commands (not options)

GPG has several commands. They come near the end of the invocation. The ones we’ll care about are:

--gen-key
--gen-revoke
--list-keys    -k
--verify
--encrypt      -e
--decrypt      -d
--sign         -s
--cl(earsign)
--fin(gerprint)

Some later uses:

--fingerprint
--recv-keys
--send-keys
--edit-key

Options alter the way commands behave. Most of the options we can set permanently in our config file. We’ll get to that later. But here are some important ones:

--armor
--recipient   -r

Creating your own key

When creating your keys, you’ll want to ensure that your name is identical to what’s on your ID cards. If you use your middle name or initial on them, type it exactly as it shows on them.

% gpg --gen-key
> 1
> 4096
> 1y
> Your Full Real Name
> you@yourmail.com
> student and hacker
> confirm

Now you need to generate some entropy! Moving your mouse around as instructed might not be enough. Here’s something to run which will speed things up.

% haveged -n 0 | dieharder -g 200 -a

Take a look at your new key!

gpg --list-keys

gpg --list-keys you«tab»

Revocation key

Adding a picture

Your pic should be a JPEG of dimensions 240 wide by 288 tall. Aim for 4 KB in size. If you don’t have a good headshot, use your webcam with a solid background. Capture part of your shoulderblades, and all of your head. Crop it down, and export to a fairly low resolution/quality. I like gimp for this. Tune the size until you get down to ~4KB. (show vid of how to do this)

Now let’s add it.

gpg --edit-key <your-key-ID> addphoto
> /full/path/to/you.jpg
> save

GnuPG will then ask you for the filename of your JPEG image. Specify the complete path.

Configuration

There’s a file in your ~/.gnupg directory called gpg.conf. This contains several settings that affect the way gpg behaves. Here are the settings you’ll want to enable:

% vim ~/.gnupg/gpg.conf
---
keyserver hkp://keys.gnupg.net
no-greeting
keyserver-options auto-key-retrieve
armor
list-options show-photos
photo-viewer "feh --title 'GPG: KeyID 0x%k' %i"
keyid-format long

Upload your key to a key server

Upload your key after once you’re absolutely certain you’ve done this as described. Once a key gets posted, the only way to remove it is with a revocation key.

Getting others' keys

gpg --recv-keys

gpg --import

Get a [well trusted GPG guru’s key](http://pgp.mit.edu/pks/lookup?op=vindex&search=0x9CDD9A214EBA9723). Take a look at that page and note that his keyID is 4EBA9723. Grab it.

gpg --recv-keys 4EBA9723

Now let’s search for someone else’s key. Visit [the GPG search tool](http://pgp.mit.edu/).

Actually, we can do it from the command line:

gpg --sea(rch-keys)

Search for "Richard Stallman". Notice that there are several of them. How do you know which to trust? Head over to his site and note his message:

"to be really sure which key is mine, you need to get my key fingerprint
from me or follow a chain of signatures."

Here’s a security legend: Bruce Schneier

Some people post their pubkeys on their websites. Here are a couple examples:

Bruce Schneier: https://www.schneier.com/contact.html
Postmodern: http://postmodern.github.io/contact.html

How to make sense of gpg output

Bruce Schneier no longer keeps his current valid key on a key server. You have to go to his site to download it. Actually, select and copy it from that page and paste it into pubkey.schneier.com.asc.

Now let’s import it. This is essentially the same thing as a --recv-keys does.

gpg --import pubkey.schneier.com.asc

Let’s look at Bruce Schneier’s GPG info:

9A98966F

Notice that both of these luminaries are now using 4096-bit keys. That’s why we bumped ours up, too.

Testing dummy keys

Generate a new user on your system, or partner up with a friend.

Exchanging keys with people you meet

You should only sign keys for persons you meet face-to-face. The goal is to verify their identity, not how good of a person she is. Here’s what you need from them.

Inspecting someone’s key

Check their fingerprint

View their picture. gpg --list-keys --list-options show-photo mde

Key-signing parties

Other tools

Entropy generation (haveged, dieharder): haveged -n 0 | dieharder -g 200 -a

Seahorse key manager GUI

Other cool uses for GPG

bitcoin privacy

Terminology

Web Of Trust (WOT) — a network of folks who have signed each others' keys
subkey — same as a pubkey (public key); pub and priv are each "sub"-keys since it takes them both together to make the "full" key.
key server — keys.gnupg.net, pgp.mit.edu
PKI — Public Key Infrastructure (the systems, people, and keys that service the WOT)
gpg — CLI interface with a lot of options
.asc — a plain ASCII file encoding; basically plain readable (not binary) text
.sig
fingerprint — a long hex string identifying they person/key; view with:
keyID — a short version of the fingerprint; these are shown everywhere! eg, 299C28F0
signature — the signings of a given key, the more the better
signing
hkp — Horowitz Key Protocol, eg: hkp://pgp.mit.edu
certificate
non-repudiation
rsa — the only algorithm you’ll want to use
base64 — the encoding of ascii you can read

Stack Overflow’s Motivation Engine

Mon, 20 Jul 2015 00:00:00 -0700

Audience: programmers

You’ve spent plenty of time on Stack Overflow. Google loves it. Several visits per day? But unless you’re one who answers questions there, you’re probably not aware of how they get so much participation.

I’ve recently been answering questions on Stack Overflow. Well, I had to in order to be able to do things like upvoting. Aren’t we obligated to upvote when someone has taken the time to teach us something valuable? And that was the first hook. But it turns out that SO has a very sophisticated set of motivators to keep you participating … frequently!

What first puzzled me was how so many other users there had such high reputation. You might think that 1,000 points came from answering 1,000 questions. But it’s an elaborate point system. You feel yourself growing points at a fairly rapid clip. It would sure be nice to have a k (thousand) next to your name, right?!

Get Busy!

You eventually realize that you’re never going to be the first to answer a question unless you’re tuned into a near real-time picture of what’s happening with your tags of interest. The best way to earn points is to be the first to answer and get your answer accepted. So you subscribe to be updated via email.

Every sub-site requires another set of reputation. You’ll quickly find yourself trying to answer questions on other Stack Exchange sites.

Way More than Badges

Sure, you earn badges. But you have to do more and more to earn the next type of badge. You even have your “next badge” dangled from your profile. The badges are more like abilities. And there are three categories of them: bronze, silver, and gold. It’s pretty challenging to get even your first silver.

Each badge is documented. You know what you have to do to earn the archaeologist badge: edit some old posts.

Ultimately, people are on SO to prove their worth and get hired. So the

Surprises

You’re given a pleasant surprise when they tell you that they’ve removed ads since you’re such a great participant.

There’s an invisible goal of getting to 200 points. It opens a few doors, but you have to poke around to discover that it’s a key number. When you finally hit it, you’re invited to join the “Careers” portal and create a resume. You also suddenly get a 100-point boost across all the sites in the network. This was huge!

Not Social

It’s pretty interesting that there is no notion of “following”. You can’t even “message” someone.

Gaming It

I’m not going to bother trying to game this, because I don’t (think) I care too much about my reputation points. But it can be done. I see people asking questions that they shortly thereafter answer themselves.

I suppose you could also create a dummy account that spends a lot of its time upvoting your real posts.

Vi-Mode Ubiquitous Cursor Indicator

Mon, 20 Jul 2015 00:00:00 -0700

Audience: programmers

It should be as easy as possible to tell if you’re in normal or insert mode. Your eye tends to be on your cursor, so you’ll find the cursor to be the best indicator of your mode. Of course, you’re effectively in Vim when in Zsh (bindkey -v, right?), too, so it should have the same cursor indicator.

This recipe has been described scattershot in various places, but never comprehensively. This version will give you a solid block cursor in normal mode, and a blinking, gray underscore cursor in insert mode. I’ve also set it to green block for Zsh, blue for Vim. Change it to whatever you like. It’s big and bright so you can easily find it. Then it’s small and flashing to remind you to get out of insert mode. Whatever colors/styles you choose, rejoice that it now works!

I worked for a couple years without having this working in Tmux and it drove me crazy. Now that it works well, I find myself using Tmux much more often.

This has been battle tested in URxvt, but it also seems to work in Xterm and Termite.

Zsh

~/.zshrc

# Modal cursor color for vi's insert/normal modes.
# http://stackoverflow.com/questions/30985436/
# https://bbs.archlinux.org/viewtopic.php?id=95078
# http://unix.stackexchange.com/questions/115009/
zle-line-init () {
  zle -K viins
  #echo -ne "\033]12;Grey\007"
  #echo -n 'grayline1'
  echo -ne "\033]12;Gray\007"
  echo -ne "\033[4 q"
  #print 'did init' >/dev/pts/16
}
zle -N zle-line-init
zle-keymap-select () {
  if [[ $KEYMAP == vicmd ]]; then
    if [[ -z $TMUX ]]; then
      printf "\033]12;Green\007"
      printf "\033[2 q"
    else
      printf "\033Ptmux;\033\033]12;red\007\033\\"
      printf "\033Ptmux;\033\033[2 q\033\\"
    fi
  else
    if [[ -z $TMUX ]]; then
      printf "\033]12;Grey\007"
      printf "\033[4 q"
    else
      printf "\033Ptmux;\033\033]12;grey\007\033\\"
      printf "\033Ptmux;\033\033[4 q\033\\"
    fi
  fi
  #print 'did select' >/dev/pts/16
}
zle -N zle-keymap-select

Vim

~/.vimrc

" http://vim.wikia.com/wiki/Configuring_the_cursor
" Tmux details: http://reza.jelveh.me/2011/09/18/zsh-tmux-vi-mode-cursor
if &term =~ "xterm\\|rxvt"
  " Insert
  let &t_SI  = "\<Esc>]12;gray\x7"
  let &t_SI .= "\<Esc>[3 q"
  " Normal
  let &t_EI  = "\<Esc>]12;green\x7"
  let &t_EI .= "\<Esc>[2 q"
  autocmd VimLeave * silent !echo -ne "\033]112\007"
elseif &term =~ "screen-it"
  " Insert
  let &t_SI  = "\<Esc>Ptmux;\<Esc>\<Esc>]12;gray\x7\<Esc>\\"
  let &t_SI .= "\<Esc>Ptmux;\<Esc>\<Esc>[3 q\<Esc>\\"
  " Normal
  let &t_EI  = "\<Esc>Ptmux;\<Esc>\<Esc>]12;blue\x7\<Esc>\\"
  let &t_EI .= "\<Esc>Ptmux;\<Esc>\<Esc>[2 q\<Esc>\\"
  autocmd VimLeave * silent !printf "\033Ptmux;\033\033]12;grey\007\033\\"
endif

Tmux

I like to keep these lines in my .tmux.conf so I can easily access the infocmp and tic commands to run on new machines.

Note that TERM will be auto-set by Tmux now to screen-it.

One time tmux setup commands (keep around in ~/.tmux.conf)

# One-time setup for italic support (instead of reverse).
# http://tmux.svn.sourceforge.net/viewvc/tmux/trunk/FAQ
# % infocmp screen-256color |
#   sed -e 's/^screen[^|]*|[^,]*,/screen-it|screen with italics support,/' \
#     -e 's/%?%p1%t;3%/%?%p1%t;7%/' \
#     -e 's/smso=[^,]*,/smso=\\E[7m,/' \
#     -e 's/rmso=[^,]*,/rmso=\\E[27m,/' \
#     -e '$s/$/ sitm=\\E[3m, ritm=\\E[23m,/' \
#     >| /tmp/screen.terminfo
# Compile and create binary file ~/.terminfo/s/screen-it
# % tic /tmp/screen.terminfo

# This is actually active.
set -g default-terminal "screen-it"

Addendum

There is still an issue where on Tmux pane/window changing, the cursor stays in the mode that its last pane/window was in.

Clojure, Vim, nREPL, Fireplace, REDL Setup

Mon, 13 Jul 2015 00:00:00 -0700

These are the steps I take to set up a new Arch system with a Clojure environment for vim.

Get lein up to date
```
lein update
```
Install new version of clojure, eg, Arch: yaourt -S clojure
Update lein search index: lein search whatever

Set up fireplace, highlighting, mappings, sexp into .vimrc with Vundle:

Plugin 'guns/vim-clojure-static.git'
Plugin 'guns/vim-clojure-highlight.git'
Plugin 'tpope/vim-leiningen.git'
Plugin 'tpope/vim-dispatch.git'
Plugin 'tpope/vim-fireplace.git'
Plugin 'tpope/vim-sexp-mappings-for-regular-people'
Plugin 'guns/vim-sexp'
Plugin 'guns/vim-slamhound'
Plugin 'dgrnbrg/redl'

Add to ~/.lein/profiles.clj:

{:user {:plugins [...
                  [cider/cider-nrepl "0.10.0"] ]
        :dependencies [...
                       [spyscope "0.1.5"]
                       [redl "0.2.4"] ]
        :injections [...
                     (require 'spyscope.core)
                     (require '[redl complete core]) ]}}

Create new project:
```
lein new foo
```

Add to each project:

:main foo.core
:repl-options {:init-ns foo.core})

Run lein deps
Start tmux? Maybe not; slime not working now anyway

Now you need an nrepl running somewhere. You can either:

Start lein repl in a terminal
Or, in vim, run: :Console to fire up nrepl in a new shell (or tmux window if tmux is running)

Now finally….

Fire up vim if you haven’t already (fireplace will auto-connect to running nrepl)
In vim, run: :Eval (require '[redl core complete]) (might not be necessary for you)
Start redl with :ReplHere

Start drip (optional)

export LEIN_JAVA_CMD=drip  # could make lein hang on app template

Stop drip (later) with drip kill

TLDR for next time

% cd some-project
% lein repl  # and twiddle your thumbs
% vim src/.../foo.clj
" Play with fireplace commands, like cpp
:Eval (require '[redl core complete])
:ReplHere
" Do things in vim in the real nrepl!

Using Gist As Your Blog

Tue, 07 Jul 2015 00:00:00 -0700

Github’s Gist is almost good enough as a blog. If you don’t want to take the time to set up your own blog, you could probably get away with using gists. As an example, this is a pretty decent index display.

Where it shines

nice comment system (example)
markdown support
auto-abstracts (shortened posts in index)
built-in editor or use git
store associated files with your article in a real git repo
nothing to host yourself

Where it falls short

no global feed
people don’t expect it to serve as your blog
gets cluttered with other snippets
google will not index these well
no analytics
it seems unlikely that someone will like your post and decide to go explore your other gists

Conclusion

Gists are great. Even if you set up a real blog, you’ll still want to use gists to host code samples.

Docker as a Full CentOS

Sun, 05 Jul 2015 00:00:00 -0700

Docker has arrived. It’s a "container" system for isolating services. It’s simpler and lighter than a VM, yet easier to use than a jail. But it’s not quite a full OS: it usually lacks things like systemd, cron, sshd, syslog, etc. Some folks are trying to address this for Ubuntu. It turns out that this can also be done with CentOS 7! This all-in-one docker instance becomes a great vehicle for testing deploys (and probably much more).

Ubuntu wasn’t going to work for my needs, but I found a minimal CentOS 7 version of the Ubuntu approach. So now Docker can actually be used for testing deployments with almost real full OSs.

Docker With CentOS 7

On your local host, stop docker if running (to reset IPs) and start up the docker service:

systemctl stop docker.service
systemctl start docker.service

Maci has provided an article and repo to get centos7 working with docker, which this article extends.

Get it (one time ever):

git clone https://github.com/maci0/docker-systemd-unpriv
cd docker-systemd-unpriv

Build (one time ever):

alias dk=docker  # put in ~/.zshrc
dk build --rm -t maci/systemd .

Fire up an instance any time, setting hostname etc:

dk run -h dk1 --rm -t -i -p 2221:22 -v /sys/fs/cgroup:/sys/fs/cgroup:ro maci/systemd /usr/lib/systemd/systemd

Switch to other term.

See the IP:

dk ps
dk inspect 097241cd8024 |grep IPAddress

Test login:

sshpass -p root ssh dk1
# Oops. Wipe existing/offending key.
sed -i '47d' ~/.ssh/known_hosts
sshpass -p root ssh dk1

Manually update the system:

yum update

Optionally save as latest/greatest (see also):

dk commit c0d3c28f5a86 mde/centos71

Manually install the very basics, and set up a deploy user, say “dummy”:

# yum -y install openssh-clients sudo; useradd -m -G wheel dummy; passwd dummy

Get dummy into a good state:

# su - dummy
% ssh somewhere-valid
> yes  # then ^c, just wanted proper .ssh/ dir created

Set up to watch progress in a logged in shell:

% sudo journalctl -xaf

Copy your ssh key onto it:

scp ~/.ssh/id_rsa.pub dk1:~/.ssh/authorized_keys

Run ansible toward it:

time ansible-playbook --skip=skip,security,nondocker -u dummy -b --ask-become-pass -l offsvrs:172.17.0.1 site.yml -v ; beep

When you’re done testing, shut down instance:

dk ps
...
dk stop ea970de7e735

Save the image:

dk save -o centos7-systemd-maci.img.tar maci/systemd:latest
gzip centos7-systemd-maci.img.tar

Archive it to S3:

s3.sh put centos7-systemd-maci.img.tar.gz s3://dockers.example.com

Helpers

Generate hashed password:

python2 -c "from passlib.hash import sha512_crypt; import getpass; print sha512_crypt.encrypt(getpass.getpass())"

Script to quickly remove a key, ~/bin/sshrmkey:

#! /usr/bin/env zsh
# sshrmkey — delete a line containing stale/offending key
line=${1?Must provide offending line}
sed -i "${line}d" ~/.ssh/known_hosts

% sshrmkey 42

Vagrant/Virtualbox

If you really want to avoid Docker but still test your deploy on CentOS 7, you can accomplish much of the same setup with Vagrant.

Install:

y -S vagrant

Set up kernel: http://unix.stackexchange.com/questions/131792/

sudo depmod [3.19.2-1-ARCH]
sudo modprobe vboxdrv

Choose work area:

md ~/exp/vagrant/t1

Find a box: http://www.vagrantbox.es/

vagrant init hashicorp/precise32 # OR
vagrant init https://f0fff3908f081cb6461b407be80daf97f07ac418.googledrive.com/host/0BwtuV7VyVTSkUG1PM3pCeDJ4dVE/centos7.box
[vagrant up]??

vagrant ssh

Better:

sshpass -p vagrant ssh -p 2200 vagrant@127.0.0.1

Consult: http://docs.ansible.com/guide_vagrant.html

Add to generated Vagrantfile:

config.vm.provision "ansible" do |ans|
  ans.playbook = "playbook.yaml"
end

Start it:

vagrant up

Create hosts file:

>hosts
[foos]
127.0.0.1:2200

Create a playbook.yaml:

- hosts: foos tasks: - name: install zsh yum: name=zsh state=present

Run ansible:

ansible-playbook -i ./hosts -u vagrant playbook.yml -ksK

From Markdown to Asciidoc

Thu, 02 Jul 2015 00:00:00 -0700

UPDATE 2017: I’m going to move everything to org-mode or Markdown since I’m no longer finding the case for adoc compelling enough.

Markdown has become the de facto standard for plain text syntax. It’s supported in the webform editors of Stack Overflow, Github, and many blogs, wikis, and forums. It’s built into most static site generators. You can even use it to write a book. It’s fantastic that it has raised awareness of text-based markup, but it’s not enough.

Asciidoc fills in many of the shortcomings of Markdown. Here’s a cheat-sheet to give you a feel for its syntax. It’s almost as simple as Markdown, and thus quick to learn.

Markdown Shortcomings

You’re probably aware of most of these, but maybe don’t notice the pain as much as you should.

Comments are clumsy. And multi-line becomes a mess.

Vim ends up loading its HTML syntax which clutters functionality and causes confusion.

No good way to add extra markup without dropping into HTML.

No tables, citations, footnotes, or sub-/super-scripting.

Inferior to Asciidoc’s Docbook toolchain.

Asciidoc Extras and General Niceties

Consistency of section delimiters. All are four characters and delineate blocks: line-wise pairs of quadruples - (code), _ (quote), / (comment), = (caption), + (pass-through HTML).

Titles can be added to most sections.

Auto-up-converting of some punctuation, like the pedant’s apostrophes — and yes, even dashes.

You can add anchors.

Auto-generated Table Of Contents.

Markdown-to-Asciidoc Conversion Guide

Headings

Markdown:

## Foo

Asciidoc:

== Foo

Links

Markdown:

[This is Google](http://google.com)

Asciidoc:

http://google.com[This is Google]
link:/relative-page[some relative page]

The Asciidoc feels more natural to me. My first instinct when inserting a link is to insert the link itself. It’s also nice to avoid the parens. Also, I often will type a paragraph that has a few things that need to be linked after the fact. It’s really easy to paste the link just before the text in Asciidoc.

Images

Markdown:

![Mittens is my fave](/img/kitty1.jpg "My Cat")

Asciidoc:

image:/img/kitty1.jpg[My Cat]  Mittens is my fave] "My Cat")

Comments

Markdown:

<!-- just a comment -->

Asciidoc:

// just a comment

or multi-line (yay!):

////
a bunch
of comment
lines
////

Code Fragments

Markdown:

    This is indented, yet subtle and easily mishandled when mixing with lists.

Asciidoc (weird but easy enough):

  ----
  This is left-aligned, or wherever you want. It is explicit.
  ----

Asciidoc also supports Markdown-style indents, but I’m finding that being explicit is less susceptible to ambiguous translating.

HRs

Markdown:

  ----

Asciidoc (weird but easy enough):

  ''''

Definition lists

Asciidoc is much richer, and not significantly harder to learn.

Cryogen Blog Setup

Thu, 02 Jul 2015 00:00:00 -0700

The tech running this blog is described on the About page. This recipe explains what I did to set it all up.

Infrastructure

You can set up a static site easily enough with Github pages, but I think it’s nice to manage a server yourself. You might want it for other things, and you get to control it completely. Your learnings there will apply to any other site/server you host.

You can get yourself a “Droplet” at DigitalOcean for $5 USD per month. That’s cheap. It’s just a matter of a few clicks on their simple control panel. I’m somewhat near San Francisco, so I chose that data center. I like CentOS quite a bit as a server OS, but I also like to play around with FreeBSD, so I chose that. It’s a recent addition to the DO arsenal, and is a rock-solid OS with a fantastic security record and a very famous file system: ZFS.

Deployment

I’ve configured Ansible to push changes to the Droplet. Take a look at the simple playbook. I’d normally have set this up hierarchically with roles, but this machine’s config is simple enough to fit in a single file.

Any time I feel like deploying, I can simple run deploy.zsh to fire the ansible-playbook command.

Git Versioning

I like to commit often, but I don’t rely on git for updating the blog. I do maintain the engine, styling, and text all in a single repository. I usually commit when a new post is added, and more frequently as it nears completion. Probably a good idea to have a deploy cadence that’s in line with git-commits.

Cryogen

Although I’ve looked at Jekyll, Octopress, and several others over the years, Cryogen is looking like a winner for a few reasons.

minimal code base
one of the developers is the most prolific author of clojure web dev
they’re very responsive to issues
it’s already got bootstrap, and is thus mobile-friendly
no engine to run on the server; just deploy the static public/ directory
it supports Asciidoc, which is superior to Markdown
it comes with a base theme that is easy to style; just tweak the existing HTML template files that are in your project.
Google Fonts are included. I really like WhatFont for Chrome for showing fonts. Try it here to see what I’ve chosen.

The documentation is small and great, and you can start running your blog locally by following this tiny guide.

Things you can add

Add feedburner as the RSS feed. This takes load off your server as you start getting subscribers who may hit your feed frequently/automatically. You just need to edit your base.html to replace the feed link to point to your feedburner XML.

Google Analytics is a simple way to see your site traffic. It’s a simple matter of pasting a tiny javascript snippet in the bottom of your base.html.

Videos can be embedded. You could use Youtube, but Vimeo might be better at not pointing to random, odd videos as recommendations.

Things that are not needed

tag clouds
ads
wysiwyg editing
user management
a comment system (spam is insidious), but Disqus is an option
backups (they’re already in git)
blogrolls
emailer
categories
widgets for “like”ing or twitter updates

Although I use CloudFlare elsewhere to protect from DDoS attacks (been hit before) I don’t see much need for it for a blog. It could be added.

Things that may be coming to Cryogen

Should I Run Today?

Mon, 16 Feb 2015 00:00:00 -0800

Probably…

It’s not downpouring or freezing or broiling.

My phone is charged and GPS is toiling.

My gear is nearby.

Runner’s high makes me feel I can fly.

I’m not sick, injured, hung over, or feeling too sadly.

Nothing is hurting too badly.

I have (semi-)waterproof shoes.

I really have nothing to lose.

It’s not too early or too late.

Better get out there. Don’t test fate.

If I don’t…

I will lose progress.

My stats will be a mess.

I will gain weight.

I won’t feel great.

The next event will hurt even worse.

I might have to see a nurse.

I won’t get to hear a podcast.

Run those miles as if they’re my last!

LiveScript vs ClojureScript

Sun, 01 Feb 2015 00:00:00 -0800

The following are my pros/cons notes comparing LiveScript (which I really loved using) to Clojure(Script), and eventually to Racket. The conclusion was that ClojureScript wins, partly because of my other biases toward Clojure.

LS

Pros

concise, haskell-like
improved coffee, a very popular language
npm
node is fast
beautifully simple standard node lib
brunch et al
jade (hiccup might suffice, but there is clj-jade)
angular/backbone
express
socket.io
d3 (but c2)
native json
many lessons/projects already written in ls
put into any proj that uses coffee
testing frameworks
plugs into everything where js is used with minimal change

Cons

callback hell
impossible async recursion (and no tco)
not multi-threaded so maybe harder to scale for production
poor repl
too many npm pkgs to choose from
won’t paste into browser repl
bad vim syntax highlighting (fixable)
node won’t go on windows (anyone care?)
prelude confused with underscore/lodash/async/nimble
obscure
syntax heavy; a bit quirky
surprising scope issues
JavaScript\* community fragmented among langs/tools

CLJ(S)

Pros

lisp, beautiful functional
a fit for every domain
immutability
avoids node event loop
4clojure for practice/competition
multi-runtime options (java, node, browser)
maybe preferred by academics
browser repl?
native structures more expressive/concise than json and racket’s
edn
concurrency
sensible scoping
easier to teach (vs ls), been done many times
laziness
clojure toolbox (nicely settles on a few tools for any job)
many settled libs: korma/sql, hiccup/templating, luminus/web, incanter/stats, midje/testing
obviates ChucK with Overtone
lighttable as drracket competitor
om/reagent/react
practical real-world, employable skillset
js compatible (ClojureScript)
simple web deployment via uberjar/uberwar to jetty, tomcat, or nginx
google closure compiler/optimizer (though heavy)
macros

Cons

too bulky for raspi!
memory hogging beast! so not good for kids learning on limited hw
slow startup? (but maybe okay since single repl stays alive for days)
lots of parens, more verbose
prefers emacs (but PG uses vi)
heavy on java and suffers from its limitations
RPN opaque for beginners
lacking JavaScript/node/npm ecosystem?
complexity of setup
terrible error messages, but clj-stacktrace

Racket

Pros

fast and light and easy to generate executables (for meager hardware)
nice, kid-friendly starter book (Realm of Racket), plus HtDP
actually is plt-scheme, so little schemer and sicp also apply
has graph plotting and math modules
well accepted as academic/teaching language, with scheme history
many teaching resources, maybe even full course
well contained/organized documentation
might want to build everything from scratch anyway, for teaching purposes
DrRacket
nice repl(?)
scribble documentation
a scribble-based blog engine
friendly error messages
most flexible language (toolkit)
accepts [] in place of ()
language "teach" packs
decent startup time: 230ms for hello.rkt, 46ms with just racket/base
no java to deal with
probably nice small install with racket-minimal from aur, excluding DrRacket
pretty simple to move to clojure from racket, later on
probably does recursion right
true pattern matching(?)
nice unicode identifier support, even as symbols! use λ instead of lambda
raco (lein equivalent?)
lang hosted on github
browsable package repo: http://pkgs.racket-lang.org/ and http://planet.racket-lang.org
only 20 MB for racket-minimal install
probably great tdd testing utils

Cons

syntax not as brief as Clojure
lacking ecosystem (web framework, templating, overtone, etc)
no vim plugins like fireplace/vim-sexp? (workflow)
lacking libraries (mongo, etc)
lacking syntax; everything is parens: harder to read (but [] accepted)
less powerful data structures
maybe not scalable? well, people claim it’s faster than python
no good js transpiler story (whalesong?)
a little bulky to install at 400 MB (but sans-DrRacket pkg available
docs not as friendly as http://clojuredocs.org/

? npm equivalent? maybe raco planet

ES6

Cons

still just an ugly and verbose [braces and semicolons] syntax
will need transpilation for some time, so might as well use another lang

OCaml

fast
statically typed
tools can be very good
immutable by default
growing in popularity
like haskell but better/simpler
great completion
utop repl
ocsigen web
good error messages
interfaces are slick

Cons

syntax heavy
no mixed types in lists (http://www.paulgraham.com/lispfaq1.html)
slime is clumsy with ;;
lots/hard to teach

R

Pros

vector oriented
replaces graphing calculator
fits math/stats curriculum
libraries
graphing
shiny
fast and light
fantastic repl and help system
math and data oriented
so many books/learning resources
industry standard
rstudio(?)

Cons

no hash/dict native
not a lisp
syntax can be awkward and a bit ugly
not very web oriented(?)
have to know stats to do much
probably not as good tdd testing utils
maybe slow for big data sets/crunching

Compelling RStudio Features

Pros

spreadsheet
searchable help and libs
graphic window mgmt

Cons

binary is 260 MB
bad fonts and colors
mouse-oriented

But what do they want to build?

web apps
graphs/stats/analytics/reporting/journalism
parallel/fast improvements
games
robots
back-end service
cars
automation
system tools
interfaces
iot/devices (home automation: lights, garage door)
making music
language processing
measuring instruments (farming, atmosphere, seismology, etc)
or whatever, there are lots of jobs if that’s the end goal

Requirements

concise
functional
easy enough to learn
simple environment
minimal machine/$ resources
multi-domain
somewhat visual
fun and not painful