This keeping in sync hasn't worked out, so I wrote this little script to convert the vim colors to the gvim ones:

Download the makegvim script, and use it like:

$ ./makegvim < ~/.vim/colors/<yourfile> > /tmp/x
$ mv /tmp/x ~/.vim/colors/<yourfile>

And now the colors of gvim should be identical to those of vim.

Note: colors like 000 must be used like cterm=0 otherwise the conversion fails (the script isn't that smart).

But how do you merge a commit from a forked git repository? Turns out it is not that difficult.

The commit I want has the hash 5a11e88ddbef4ce7513aae93bdcd377449f45efb.

The steps:

• Create a remote branch:

  git remote add hamnis https://github.com/hamnis/pandoc2rfc
  

• Fetch the contents of it:

  git fetch hamnis
  

• Cherry-pick the commit you need:

  git cherry-pick -c 5a11e88ddbef4ce7513aae93bdcd377449f45efb
  [master 7501f13] transform.xsl: Supporting the output from pandoc 1.8.2.1:  
  * table/title 
  instead of table/caption  
  * table/tgroup/thead/row/entry instead of table/thead/tr/th  
  * table/tgroup/tbody/row/entry instead of table/tbody/tr/td
   Author: Trygve Laugstøl <trygvis@inamo.no>
   1 files changed, 3 insertions(+), 3 deletions(-)
  

Voila.

I like to think of people going to IETFs as tinkerers: they want to develop new protocols or make existing ones better. I would say perfect Linux users!

But no, most of them prefer Mac OS X, why? Because "it just works". And this is true. If you use Linux on a laptop you will probably need to fiddle a little to get everything working. On Mac OS X this isn't the case, it will just work.

Why do I still prefer Linux? Because it has thought me everything I know about computers. Especially in the old days, it needed a lot of hand holding to get boring things like sound working. I want to stay sharp, on the edge and get to know (new) stuff. I want to run a mailer daemon on my server, I want to play with new code. I want to get distracted and sometimes I'm forced to get my hands dirty and figure out how PulseAudio works. This takes, but, you will always learn something new.

If "Mail App" grinds away on the CPU and takes the load up to 100% you're stuck. If "mutt" has such a problem (if ever!), I can probably fix this.

And this is the crux of the matter... How can it be that people who want to tinker with stuff be content with a platform which is specifically designed to prevent tinkering?

I'm convinced Ubuntu can deliver the same user experience as Apple, but with 100% open source software.

Keep on tinkering!

Related reading

• The personal computer is dead

• vim (see that previous post);
• mutt (idem);
• zsh;
• dircolors;
• git (a bit).

zsh

See this file to setup the colors. Then in my prompt I have stuff like:

PS1=$'${vcs_info_msg_0_}$FG[067]%(1j.$myjobs% $FX[reset].$FX[reset])$FG[179]%#$FX[reset] '
RPS1="$RPSL%$MAXMID<...<$mypath$RPSR$FG[239]$FX[bold]$__ZH$FX[reset]${vcs_info_msg_1_}"
RPSR=$'$FX[reset]$FG[009]%(0?.$FG[reset]. $E)$FX[reset]'

For zsh I have two files that make up my prompt:

• zprompt, primary prompt setup;
• zvcs, version control vcs_info stuff.

Also see this older blog post on this setup. This leads to a prompt looking like this (click for larger):

The normal prompt is very plain. Almost nothing is shown, left the prompt % and on the right the PWD ~:

When logging in to a remote server, the hostname appears on the right:

When a program ends abnormally the exitcode is shown, in words (-INT) and red when it isn't zero:

When you background an app. the number of bg jobs appear in blue. The one with the + is the current job. Multiple jobs are separated with commas:

When you enter a git/svn/hg directory, the right side shows the type (git, svn, hg) and on the left you get the current branch.

dircolors

Modified from Solarized, not quite finished, but certainly looks nice (IMHO). See this dircolors file, I use it like:

eval $(dircolors ./dircolors)

git

The alias section from my .gitconfig:

[alias]
        st = status
        ci = commit
        br = branch
        co = checkout
        df = diff
        lg = log -p
        pl = pull
        ps = push
        timeline = log --graph \"--pretty=format:%C(192)%h%Creset by %C(bold 239)%an%Creset (%ar)%C(182)%d%Creset%n%s%n%b\" --all

The colors are selected with %C(number).

I went searching and found "xoria256" a color scheme suited for 256 color terminal and a dark background. There is even a Ubuntu/Debian package for it: vim-scripts. Unlike solarized it doesn't come with a custom palette, just use Tango in gnome-terminal (or whatever your favorite is).

But of course I wasn't completely happy with it as I wanted some more blue-ish colors in there.

So tweaked it a little, and this is the result:

I've also ported it over to mutt, so that it has a matching color theme.

• Download the vim color scheme;
• Download mutt color scheme.

Note: I haven't changed the name of the color scheme, but it should be called something different, xoria256m or something. It is also still a work-in-progress, I will probably open a git repository on github soonish.

hello       -> J ->  hello goodday
goodday

Where the cursor is positioned somewhere on the 'hello' line.

But I often find myself wanting to use the opposite, I want 'hello' to be put after 'goodday'. The cursor is now positioned on the 'goodday' line.

hello
goodday    -> K -> goodday hello

The following mapping does that:

map     K       kddpkJ

In words:

1. Go up 1 line: k
2. Delete the entire line: dd
3. Paste line below the current one: p
4. Go up again: k
5. Perform the join: J

In less words: switch the lines and then do a join.

For good measure I also want to use Omni-completion when writing Go code:

Btw, this screenshots also shows the solarized (dark) colorscheme.

Coloring

Google for solarized. In my .vimrc:

let g:solarized_termcolors=256
colorscheme solarized

Make from VIM

Use :make inside the editor and jump through the errors with:

:cn         // next compile error
:cp         // previous compile error

There are more options, but I want to be able to remember them...

Folding

Settings in .vimrc:

" folding settings
set foldmethod=indent
set foldnestmax=10
set nofoldenable
set foldlevel=0

And the commands that I will probably use most often:

zM          // close all folds
zR          // open all folds

za          // toggle fold under cursor
zA          // toggle fold under cursor recursively

Other important ones:

zo          // open fold under cursor
zO          // open all under cursor recursively

zc          // close fold under cursor
zC          // close all under cursor recursively

Spell checking

Setting in .vimrc:

" toggle spelling control-E -> en, control-N -> dutch (nederlands)                   
map     <C-E>    :setlocal spell! spelllang=en<CR>
imap    <C-E>    <ESC>:setlocal spell! spelllang=en<CR>i
map     <C-N>    :setlocal spell! spelllang=nl<CR>
imap    <C-N>    <ESC>:setlocal spell! spelllang=nl<CR>i

Commands to use (this is the only one I use)

z=          // Show corrections for a word

Toggle switches

Switches for paste-mode, cursorline, numbering disable search highlighting.

set pastetoggle=<F7>

" search hilight
map     <F8>   :nohlsearch<CR>
imap    <F8>   <ESC>:nohlsearch<CR>a
vmap    <F8>   <ESC>:nohlsearch<CR>gv

" numbering
map     <F10>   :set nu!<CR>
imap    <F10>   <ESC>:set nu!<CR>i
vmap    <F10>   <ESC>:set nu!<CR>gv

" toggle cursorline
map     <F9>   :set cursorline!<CR>
imap    <F9>   <ESC>:set cursorline!<CR>

Omni completion (Go specific)

See https://github.com/nsf/gocode. After you've installed that, you can use control-X control-O to bring up the omni completion window. With the VIM files in go/misc/vim you also have the following commands:

    :Fmt                // Gofmt your code
    :Import strings     // add package 'strings' to the import list
    :Drop strings       // drop package 'strings' from the import list

I'm assuming LDAP en Kerberos completely setup and configured and working. You get your TGT after a kinit, etc. And then you want to utilize Kerberos to password-less login using ssh.

I have a client machine foton.atoom.net, from this machine you want to login to the server. The server is elektron.atoom.net.

On the client the command, hostname -f should return the fqdn of your host, in my case:

$ hostname -f
foton.atoom.net

We're are using the fqdn in the Kerberos configuration, so they should match. On the server, it should also return the fqdn:

$ hostname -f
elektron.atoom.net

Configuring Kerberos and OpenSSH

On foton.atoom.net aka the client, add a host principle and export the key:

# kadmin
kadmin: addprinc -randkey host/foton.atoom.net
kadmin: ktadd -k /tmp/foton.keytab host/foton.atoom.net
kadmin: exit
#

Now you should have the file /tmp/foton.keytab. This must be imported the server's keytab file. In essence this file contains the password (set wth -randkey) for the host foton.atoom.net.

Next copy the file to the server:

# scp /tmp/foton.keytab miekg@elektron.atoom.net:/tmp

On the server elektron.atoom.net, you need to import the key file and then destroy it. A keytab file should be handled as a plain text password. Merging the keytab from foton.atoom.net with the existing keytab is done as follows, (maybe this can be done more efficient):

# ktulil
> ktutil: read_kt /etc/krb5.keytab
> ktutil: read_kt /tmp/foton.keytab
> ktutil: write_kt /etc/krb5.keytab1
> ktutil: quit
# mv /etc/krb5.keytab1 /etc/krb5.keytab
# rm /tmp/foton.keytab

In /etc/ssh/sshd_config you need the settings:

# Kerberos options
KerberosAuthentication yes
KerberosOrLocalPasswd yes
KerberosTicketCleanup yes

# GSSAPI options
GSSAPIAuthentication yes
GSSAPICleanupCredentials yes

In Ubuntu installing openssh-server and Kerberos should be enough to have the basics.

And that ... should be it. I'm testing this setup on another client to see if it really works and I have covered everything.

Stay the FUCK out of my windows with this crap!