mocp rand

I'm quite sure everyone reading this must have a respectable, if not massive, music collection. In this days and age is difficult finding someone who doesn't. It's also difficult to choose one, and only one, disk to listen at any given moment. Until we're upgraded to support concurrent music listening we're better of with a random disk selector, which is exactly what this little script does:

#!/bin/bash

SEARCH_DIR="/home/nico/Música"
START_RANDOM=1
RAND_MAX=32767

while (( 1 )); do
  NUM_DISCS=$(find $SEARCH_DIR -type d | wc -l)
  RAND=$(($NUM_DISCS * $RANDOM / $RAND_MAX))
  RAND_DISC=$(find $SEARCH_DIR -type d | head -n $RAND | tail -n 1)

  # Wake up moc
  mocp -FS 2>/dev/null >/dev/null &
  mocp -pca "$RAND_DISC" &
  echo "Playing $RAND_DISC"

  # Start from a random file?
  if (( $START_RANDOM )); then
    mocp --on shuffle &
    mocp -f &
    mocp --off shuffle &
  fi

  read
done

Of course, it requires mocp, my favorite music (on console) player. And obviously, you'll have to configure SEARCH_DIR but I'm sure some bash hacking is not that hard.

Beware though, using this + cron may have the undesired effect of awakening to the pleasant music of Cannibal Corpse.

C++: Magic member callbacks

Short post about C++ this time - though calling it a request would be more appropiate. I'm trying to create some kind of magic callback to do this:

class Caller {
 Callback c;
  public:
  Caller(Callback c) : c(c) {}
 void doit(){ c(this); }
};

Shouldn't be too difficult, right?

There are some hidden complexities, of course, mostly regarding the callback parameter type, but the idea is simple, keep the caller dependant only in the callback, not in the callee.

Templates are not a valid solution as the callee may have more than one callback (i.e. expect more than a single object to finish and call the callback) so the whole idea of this is having the callback "bind" to a member method when created, doesn't matter which one.

I have a solution, tough I'm not too happy about it for now. I'll post it next week, unless someone comes up with a better idea (you know how to submit it if you do, right?).

GNU/Linux: Emergency Restart

It happens: we're happily hacking on some code and out of nowhere X server freezes. It may be the latest Compiz whose at fault, or perhaps a stray program that decided it should start consuming all available CPU. Anyway, it's easier to reboot than trying to fix whatever got broken but Ctrl - Alt - Backspace is unresponsive and we can't drop to a console. It's not ussual but it happens. What can we do about it?

There's a cool shortcut to help us when shit happens, it'll reboot the computer and it's a little bit nicer than yanking out the power cord. You just need to remember REISUB and have some keyboard dexitry - holding down Ctrl - Alt - SysRQ/PrintScreen is required while typing REISUB (don't do it now, it'll reboot your computer!).

So, what's REISUB all about? It's a little bit better than a forced hard reboot because it'll:

1. R: Restore console
2. E: Send SIGTERM to all processes
3. I: Send SIGKILL to all processes
4. S: Emergency sync of all filesystems (commit any changes to the phisical media)
5. U: Read only remount of all filesystems
6. B: Reboot now

So, off course, you'll have to wait a little bit between every keystroke. Press Ctrl + Alt + PrntScreen + H on a console to get some help on every command.

Why does it work?

There's a lot of magic involved to make this secret incantation work. It involves kernels, vectors and other mythical beasts. There's a crazy thing called interruption vector; it's the place where every (hardware) event gets dispatched to a handling function. There lives a function call to handle keyboard input, amongst other things. This function call will be executed always, though the SO may just decide to queue the keyboard input if it's too busy handling something else.

Well, this key combination can't be delayed 'till later, it must be handled NOW, therefore, even if there's a stray process or a driver gone mad, it'll always be caught and the computer will be rebooted.

What's the catch? You won't be saving that precious code you we're hacking away when it all started, but at least you'll save some fscking time on the next start up.

Vim Tip: Select everything

There's an easy way to select the whole contents of the document: "ggVG". May seem like a lot at first glance but let's review it part by part:

1. gg: Go to the beggining of the document
2. V: Enter visual mode
3. G: Go to the end of the document

Easy, isn't it? Now you can press any other command to copy, delete or whatever you like.

LaTeX: Including Source Code

I'm sure every programmer has had to include source code in a document at least once, an architecture documentation for example, or perhaps as part of a presentation (beamer FTW, coming soon!). With most document formats including source code usually means writing the code and use some kind of manual syntax higlighting. Of course, any time you change the source you'll need to manualy update the document.

In LaTeX there's an easy way to handle source code. Though it was difficult to figure out, once in place this requires no maintenance at all - no need to manually syntax highlight your code nor update any files other than the source code itself. Even more, you can even change the source code language and it won't even matter in the presentation.

Preliminars

You'll need "pygmentyze" which is provided by the package python-pygments:

apt-cache search pygment
python-pygments - syntax highlighting package written in Python
sudo apt-get install python-pygments

Using it is really easy, check the manpage. Anyway, I'm too lazy to generate the syntax highlighted document by hand, let's add it to the makefile.

Automating the source code generation

Let's beging by adding a "code" folder inside our project. We'll store there all the source code files, and having them in a separated folder will enable us to add a target in the makefile to automatically update the source code in the LaTeX file.

Remember the makefile from a couple of posts back? Let's add a target:

# Hack to make it work when foo.code => foo.code.tex
code/%.tex: code/%.* code/%.aux code/%.tex
  @rm code/*.aux
 $(MAKE) -C .

code/%.tex: code/%.*
 pygmentize -f latex -O style='border=#000000,colorful,linenos=1' $< > $@

# Search each code file to format and include
CODE_FILES:=$(shell ls code/|egrep -v '.tex$ |.aux$ ' )
CODE_FILES_DEP:=$(addprefix code/, $(CODE_FILES))
CODE_FILES_TGT:=$(addsuffix .tex, $(basename $(CODE_FILES_DEP)))

main.pdf: $(shell ls *.tex) $(CODE_FILES_TGT)
  pdflatex main.tex > /dev/null

OK, maybe a couple more than one. It may seem like a lot of makefile code but all it does is define a code directory and a target to run pygmentize on each source file found there. We'll have to add a dependency in the document's target so it'll be automatically generated with each build:

main.pdf: code_frames *.tex
  pdflatex main.tex && pdflatex main.tex

and then, we'll need to clean up the new temp files:

code_clean:
 @rm -f $(CODE_FILES_TGT) code/*.aux

Don't worry, there's a link to the full makefile.

At last!

It shouldn't have been too much work and we're done anyway. To include a source code file in your document now use the include command (like include{code/foobar.cpp) and re build. I'm attaching a complete example in a zip file, with my latest implementation of a bogosort algorithm (now 50% faster).

• Makefile
• source_code_example.tar
• Compiled example project

LaTeX: including documents

This is a post from my LaTeX series - check the others too!

So far we've seen some of LaTeX advantages, and a few basic commands to get you started. Let's see a trick to be more proficient with it:

Including other tex files

You should be able to write some simple documents now, some in LyX, some in LaTeX, but you'll soon start to notice that using a single text file to create a large document becomes cumbersome. Even more so if you need to split the work between several people in a team.

There's an easy way to keep a main file and then several, smaller, files in which you can work more comfortably:

include{file.tex}

Easy, right?

Beware, you can't use an include inside an include. Why? No idea, but there's a way around this:

input{file.tex}

Quick preview

Using includes has another advantage: you can have a quick preview while working with a chapter at a time. I usually keep the following structure within my projects:

% Header declarations
% Include packages
% Document preamble
% ...

%input{chapter1.tex}
%input{chapter2.tex}
input{chapter3.tex}
% input{chapter4.tex}

Just uncomment the chapter you're working with. In big documents this has a very noticeable effect, as compiling a large LaTeX file into an enormous pdf document (several MBs) may be quite slow.

Of course, I use "input" in my main file so I can use include in the chapters themselves. I won't usually need to include other documents inside the chapters, it'd get quite messy, but it's necessary to work with embedded documents, as we'll see in another post.

Vim Trivia

Did you knew that Vim can "Make your woman smile for a week"? Me neither: http://www.vim.org/trivia.php.

LaTeX: Makefile

Remember I said that being a programmer would make you a lot more comfortable around LaTeX? The reason is quite simple, tex is just source code for a document. As with any source code in Linux (Windows too, but that is besides the point) you can use a Makefile to compile it and make your life easier.

I have already posted this Makefile in another entry but it's time to explain how it works.

all: main.pdf

main.pdf: code_frames *.tex
  pdflatex main.tex && pdflatex main.tex 

.PHONY: run clean edit
edit:
  gvim -S vim.sess

run: main.pdf
 evince main.pdf &

clean:
 @# for each .tex file, remove the extension
 @#    and delete its generated files
 @for PART in $(shell ls *.tex| sed 's:.tex::g'); do
   echo "*.out *.nav *.aux *.toc *.log *.snm *.pdf *.vrb" | \
      sed "s:*:$$PART:g" | xargs rm -f;
 done

It's rather easy, let's check it target by target:

• all: create the main document - used as default target
• main.pdf: document's target - no need to call it main.pdf, I just do it because the entry point in C programs is called "main" so I'm used to it. Also, it looks better than foo.pdf. As a side note, it runs twice "pdflatex" because it first creates the document and the second time updates the document's index.
• edit: I usually have a single document split in many files, so keeping a line to quickly open up your editor with all this files is handy. I just keep it as a Vim session, no need for more
• run: target to open up the document in a pdf viewer. I call it run so I can use it with my default mapping in Vim
• clean: clean up the files created while compiling a document. Some times it's needed if there's an error you can track - it may be a corrupted .aux file

Short entry this time - next: using source code from within LaTeX.