I've become mostly indifferent to what language something is written in

July 31, 2016

In a comment on this entry, Opk wrote (in part):

Will be interesting to hear what you make of git-series. I saw the announcement and somewhat lost interest when I saw that it needed rust to build.

I absolutely get this reaction to git-series being written in Rust, and to some extent I share it. I have my language biases and certainly a program being written in some languages will make me turn my nose up at it even if it sounds attractive, and in the past I was generally strongly dubious about things written in new or strange languages. However, these days I've mostly given up (and given in) on this, in large part because I've become lazy.

What I really care about these days is how much of a hassle a program is going to be to deal with. It's nice if a program is written in a language that I like, or at least one that I'm willing to look through to figure things out, but it's much more important that the program not be a pain in the rear to install and to operate. And these days, many language environments have become quite good at not being pains in the rear.

(The best case is when everything is already packaged for my OSes. Next best is when at least the basic language stuff is packaged and everything else has nice command line tools and can be used as a non-privileged user, so 'go get ...' and the like just work and don't demand to spray things all over system directories. The worst case is manual installation of things and things that absolutely demand to be installed in system directories; those get shown the exit right away.)

In short, I will (in theory) accept programs written in quite a lot of languages if all I have to do to deal with them is the equivalent of '<cmd> install whatever', maybe with a prequel of a simple install of the base language. I don't entirely enjoy having a $HOME/.<some-dir> populated by a pile of Python or Ruby or Perl or Rust or whatever artifacts that were dragged on to my system in order to make this magically work, but these days 'out of sight, out of mind'.

There are language environments that remain hassles and I'm unlikely to touch; the JVM is my poster child here. Languages that I've never had to deal with before add at least the disincentive of uncertainty; if I try out their package system and so on, will it work or will it blow up in my face and waste my time? As a result, although I'm theoretically willing to consider something written in node.js or Haskell or the like, in practice I don't think I've checked out any such programs. Someday something will sound sufficiently attractive to overcome my biases, but not today.

(As mentioned, I generally don't care if the program is available as a prebuilt package for my OS, because at that point there's almost no hassle; I just do 'apt-get install' or 'dnf install' and it's done. The one stumbling block is if I do 'dnf install' and suddenly three pages of dependent packages show up. That can make me decide I don't want to check out your program that badly.)

In the specific case of git-series and Rust, Rust by itself is not quite in this 'no hassle' zone just yet, at least on Fedora; if I had nothing else that wanted Rust, I probably would have ruled out actively looking into git-series as a result. But I'd already eaten the cost of building Rust and getting it working in order to keep being able to build Firefox, and thus at the start of the whole experience adding Cargo so I'd be able to use git-series seemed simple enough.

(Also, I can see the writing on the wall. People are going to keep on writing more and more interesting things in Rust, so sooner or later I was going to give in. It was just a question of when. I could have waited until Rust and Cargo made it into Fedora, but in practice I'm impatient and I sometimes enjoy fiddling around with this sort of thing.)

This casual indifference to the programming language things are using sort of offends my remaining purist insticts, but I'm a pragmatist these days. Laziness has trumped pickiness.


Comments on this page:

By Greg A. Woods at 2016-08-10 20:26:47:

I haven't tried to build/use anything written in Rust yet. I'm hoping it's relatively painless. :-)

I fought long and hard to build git-annex from scratch. It is written in Haskell. Never, ever, again will I even peek at anything written in Haskell (even if the language itself could be amazing and wonderful).

I will also immediately erase any CMakefiles I find (and write a quick and simple set of portable BSD Makefiles). I would do the same to configure.ac and Makefile.am files too, but they rarely make my life more difficult, whereas CMake is always a nightmare from hell.

I would never install anything written in Perl any more if it were not for pkgsrc handling all the dependencies for me. Most Ruby stuff I avoid -- it's too much hassle (and the interpreter is a pig that can't go faster than a snail stuck in a molasses jar in January). PHP is dead to me (and always has been). JavaScript and Java, well, they're both as bad or worse than Haskell on the build-anything-significant front, and they are also both painful and/or tedious languages to use.

Yup, I'm too lazy and too jaded to deal with things that make life more difficult for no imaginable reason. :-)

Written on 31 July 2016.
« (Not) changing the stop timeout for systemd login session scopes
My new key binding hack for xcape and dmenu »

Page tools: View Source, View Normal, Add Comment.
Search:
Login: Password:
Atom Syndication: Recent Comments.

Last modified: Sun Jul 31 19:47:07 2016
This dinky wiki is brought to you by the Insane Hackers Guild, Python sub-branch.