I do most of my development work (bash, ipython, vim) in a terminal. Some of it involves working remotely on other machines, and demonstrating things for others (e.g., pair programming). I need different setups for each of these. I spend most of my time hacking away in a local shell, so for that I want optimized font, color, size, etc. Then when I share I need to make the font way bigger. And when I’m on a different machine I like to have a different color window (in addition to a custom prompt color) so I don’t forget where I am. So those are the three basic tweaks that are critical for most people. You can probably make those tweaks with most xterm-clones.

I’ll assume you’re using GNOME already. You can get a feel for the gnome-terminal feature set by simply firing up an instance: Applications -> Accessories -> Terminal. But I suggest you right-click it instead, and “Add this launcher to Panel“. In fact, do that a few times; we’ll customize each differently.

Now from an open instance, you can explore the options by invoking:

$ gnome-terminal –help

Profiles

There are profiles. Create a few. This is pretty important. If you’ve only got a “Default” profile, every time you change it, you’ll affect every other open window.

Font

I’m very picky about having the tiniest font that will work. I can actually look at 380 lines of code at a time on a humble (1920×1200) 15″ laptop screen. To achieve this I have to go with a non-antialiased (bitmap?) font. The generically named “Monospace-7″ is not beautiful, but works well for optimizing screen real estate. It’s also the only bitmap font I’ve seen that renders italic/oblique well.

Monospace is also the only font I’ve seen able to scale down to 6-point and render readably. Try it — pretty amazing! I can now look at 570 lines of code (if I cheat and narrow the last window a bit) in 15″! I’ve got great near vision, but I have to be really close to the screen to read it at 6, so I’ll go back to 7. You could also easily install other more appealing bitmap fonts like Terminus (apt-get install xfonts-terminus). In fact, terminus at 8-point fits the same number of characters as Monospace at 7-point. Too bad Terminus doesn’t do 6!

Remember to stop all running gnome-terminal instances to get a new font to show up in the list.

CLI Options

Customize the CLI options with right-click, Properties. Look at the Command field and start adding options there. The first I like to add is –geometry=80×50 to set the window size; the default of 80×25 is always too small. I like to start out with a meager 80 columns to make it obvious when I’m exceeding the good old rule.  Of course I often widen manually if I’m not in code.

Automatic Remote Login

My favorite trick is to automate logging in to remote machines. It’s as simple as adding another option: –execute ssh YOU@SOMEHOST

Good ol’ top. For years it’s been the cornerstone of process control. It’s the first place we turn to hunt down a rogue process, or just to watch how resources are consumed. Sure, you could use a handful of GUI tools, but I frequently find myself working strictly in a terminal on remote machines, where top is indispensable. This is a short overview of top‘s most important features that weren’t obvious to me until I got to practicing for the LPI exam a short while back. Now I’m making use of them quite regularly. To save you from wading through the 1,000-line manpage, here are the most useful interactive commands (you don’t have to worry about the CLI options).

• z — Turn on color. Beautiful! Don’t change them unless you’re looking to waste a lot of time
• s — This is the refresh interval. The default of 3 seconds can leave you puzzled. I like to set it to one or half a second. An alternative is to just press a bunch of times whenever you want to see an update.
• 1 — Change the number of processors shown. Though not a default, this is critical now that every machine we get on has 2 to 16 procs.
• H — Show threads. Try looking at Apache with and without this.
• i — Ignore idle processes. This helps you focus only on what’s really active; and makes everything fit on the screen.
• O – Order by some field. The most useful sub-selections here are q (resident memory), k (%cpu), and a (pid). Setting this helps keep your list from bouncing its order all around.
• c — Show whole command. Essential when you’ve got multiples of a similar command running.
• u — Only show what’s happening with a single user. That’s often $USER (you!), or some other luser.
• k — Kill a process with signal of your choosing. (Bonus: look into pgrep/pkill.)
• ? — Show the built-in help screen.
• ^g — Escape out of any menu screen.

You could have seen most of this on the built-in help screen by simply pressing h or ?. But that menu has a pretty unintuitive layout, and the above is limited to the minimal set you really need. Now that you understand how everything works, and you’ve got it looking nice, just press W to write the configuration for permanent use. If you’re unhappy with the damage you just caused, just blow it away with: rm ~/.toprc

BONUS: You may have surprisingly seen “windows” in your top session, depending on what distro you get onto (maybe it was a Fedora?); that’s how I discovered them. Press h twice to get to the windows menu. I won’t get into all those details here — I don’t find the windows terribly useful, though they do appear to offer some sophisticated views. If you decide to use them, you can get started by pressing A, and then a continuously to cycle through displays. See if you can make sense of them, and then talk to me.

CAVEATS: Be careful not to run top with a fast refresh during any sort of benchmarking. It can chew up a bit of CPU time. Also, top versions vary widely depending on the distro you use; you might notice some different behavior than what I’ve described.
(This list also makes for a great sticky, as you see in the picture.)

top is a powerful tool that gives you a lot of information. If you got this far, you should now be able to make sense of most of the cryptic display, and be able to find your way around configuring it.

Seriously, it’s not going to take 700 years for FP to go mainstream. Some would argue that it already is. Python, Ruby, and others have adopted a number of FP features. Here’s all you need to get started right now and get ahead of the curve (right after you’ve installed Debian or Ubuntu).

Install Them All

I see tons more interpreters available (apt-get search …) for the main FP languages, but these are the ones that looked most stable and most widely used.

$ sudo apt-get install clisp guile-1.8 erlang ocaml ghc6

What did that just do? Okay, you can probably figure it out. But did you realize that you just put the entirety of mainstream FP and their REPLs at your fingertips? That includes interpreters/compilers for Common Lisp, Scheme, Erlang, OCaml, and Haskell. Vim and Emacs should have editing modes available for all of these.

You can invoke each of the REPLs respectively, like so.

$ clisp # Common Lisp
$ guile # Scheme
$ erl # Erlang
$ ocaml # OCaml
$ ghci # Haskell

Of course you’ll need to learn something about each of the languages to do anything at this point. But I’m just getting you off on the right foot. I’m not going to go into detail here why I chose the interpreters or languages that I did, but if you don’t know any better, these are a great start. I’m only getting started with all of these myself.

Free Online Material

You can check Amazon for books on any of these languages. Most of them are pretty expensive (except Programming Erlang, which I just ordered). But I’ll mention some free resources that all look valuable.

• Common Lisp Book (check out the sidebar on that page about the book’s popularity on Amazon!)
• Erlang Getting Started Guide (also in PDF)
• Erlang Reference Manual (also in PDF)
• Thinking in Erlang Mini-Book (PDF)
• Real World Haskell Book
• Developing Applications With OCaml

Stay Tuned

You might already be aware of the power of FP, or maybe the Wikipedia link at the top convinced you, or maybe you’ll remain a detractor. Hopefully I’ve at least whetted your appetite by showing how easy it is to get set up. I’ll plan to go into more detail about why I think FP is important in a future post (hint: performance, concurrency, code density, productivity, intelligent communities, mind-expansion, fun). I’m still in the process of discovering all the reasons.

Well, this kicks off my FP journey. Hope you’ll come along for the ride. First stop: erl

Linux distros these days tend to be pretty minimal in their default install mode. Many of us used to be in the habit of checking the “Install Everything” box in the earlier Red Hat days. But then the box disappeared, and it became a pain to get everything you needed, and most people moved on to use apt or yum, or some equivalent, to get their systems to a usable state. The modern idea is that you start out with the bare minimum to simply enable yourself to boot, fumble around, and install more stuff. Then you just use apt-get, aptitude, synaptic, or whatever, to install to your particular needs. On a fresh new Ubuntu 8.04 installation I see only ~300 packages.

After some time on a machine you probably find that you’ve manually installed hundreds (or thousands!) of packages to satisfy all your development needs. Here’s a great way to get that critical, comprehensive package list and make sure your other oft-used machines have everything you need. (You might even want this in the crontab of your primary machine; it can be helpful for recovery purposes. I’ll discuss cron optimizations in a future post. And another future post will discuss why apt-get is Ubuntu’s killer feature.)

mocushla$ dpkg –get-selections | grep -v ^lib [>/some/backed/up/place/packages.log]

The list on my primary machine shows nearly 2,000 packages now. That’s a lot! Note that I’m excluding the libraries since they tend to just be dependencies. Including them can actually make an upgrade/rebuild/recovery more difficult.

A Minimal Package Set

You may also find yourself needing to get onto freshly installed machines with some frequency. Maybe it’s a new web host, or some lab machine you need to do some work on. For time and space reasons, it’s probably not practical to start off by immediately installing your full 2,000-package set, so you’ll want to come up with a minimal set which at least makes you dangerous.

As someone who regularly sits down at other people’s machines, or at fresh new machines, I’ve found the need to have a small set of essential packages that I install, just to be productive. Here’s my list (the green).

newbox$ sudo apt-get install build-essential screen zsh corkscrew mercurial subversion python ipython pychecker pylint ctags vim vim-scripts xfonts-terminux sqlite3 tree ntp mailx postfix mutt autofs nfs-common

This will install some other dependencies, of course, but it’s a pretty quick operation, requiring less than 100 MiB. There are various other essential packages not listed there, but they tend to be part of the basic install. Now you can just use something like “hg clone ssh://your-mocushla.com/yourhome” to pull in your well-organized, minimal $HOME setup — but I’ll talk about that in a future post.

Related tip of the day: Did you know you have tab-completion for apt-get? Try this:

newbox$ sudo apt-get install python-[tab][tab]y

How many of those have you had to discover by searching?

The Meme

What’s on your Minimal APT List? Or do you have a Yum List? Does it look different?

If you found this post interesting, you may be interested in some related book s: Linux Patch Management, and Ubuntu Hacks.