demonastery.org

The Perfect Android Emulator

zane.a@demonastery.org (Zane Ashby) — Thu, 08 Mar 2012 00:00:00 +1300

I’ve recently been getting further into Android development and as most people that have touched the official SDK know, the Android emulator is giant pain in the ass to work with. The reason it is slow is a combination of many things (ARM - x86 conversion, slow screen updates), but fortunately thanks to the Androidx86 project, you don’t have to live with it any more.

The Androidx86 project aims to port AOSP to the x86 architecture and supply drivers for many common devices; it does this very well and is getting better with every release. I’m going to show you how to set up the perfect Android VM for development (this assumes you have the rest of the SDK working fine, including access to adb from the command-line).

To start off we’re going to head over to http://code.google.com/p/android-x86/downloads/list and download the iso labelled as “android-x86-4.0-RC1-eeepc.iso” (181MB). While this is downloading you will want to make sure you have a copy of VirtualBox for your platform of choice.

Once this is finished downloading and VirtualBox is installed, fire up the VirtualBox Manager application and select the “New” button from the toolbar. This launches a wizard to guide you through creating a new VM, pretty simple really.

Give the VM a name of your choice (I simply chose “Android”), select “Linux” as the Operating System, and “Linux 2.6” as the version. Next we’ll want to give the VM some memory. Choose whatever is suitable to your setup, but anything greater than 256MB should suffice. Then we’re on to setting up virtual hard disks, we can safely uncheck the “Start-up Disk” option (as we’re using a livecd) and continue to the next screen. Finally (after dismissing the warnings) you should have a brand new empty VM ready to use.

We aren’t quite ready yet though, lets tweak a couple of options before continuing. Right click on your newly created VM and select “Settings”. From here navigate to the “Storage” category, and click on the “Empty” under “IDE Controller”. On the attributes pane to the right, check the “Live CD/DVD” box, then click on the CD icon and select “Choose a virtual CD/DVD disk file…”. Select the eeepc ISO downloaded earlier.

Next jump down to the “Network category”, click the “Advanced” dropdown, and change the Adapter Type to “PCnet-FAST III”. Now click on the “Port Forwarding” button and add a new entry, setting the Host and Guest port options to 5556. Finally you can close the settings dialog and return to the main screen.

Now we’re going to set up a phone resolution (as by default Android-x86 boots in a conventional tablet resolution). To do this, right click on your VM and select “Show in File Manager” (or “Show in Explorer”). Close the VirtualBox Manager and open the .vbox file in your favourite editor and add the following lines under the <Machine> XML tag:

<ExtraData>
  <ExtraDataItem name="CustomVideoMode1" value="320x480x16" />
</ExtraData>

Save and close this file, and now we’re ready to launch our VM. Open up VirtualBox Manager again and hit start. Once presented with the boot menu, hit the TAB key. Now add UVESA_MODE=320x480 vga=864 and hit enter to boot. Your VM should resize and boot up to a welcome screen. Press Right-ctrl + I to disable “Host Mouse Integration”. Now click inside the VM and work your way through the welcome screen. You can skip pretty much everything that it asks, so feel free to do that.

Once at the home screen, open up the apps menu and scroll across to the right until you find “Terminal Emulator”. Open it up and then type the following commands:

su (this will popup a dialog, hit Allow)
netcfg eth0 dhcp
setprop ro.kernel.android.ndns 1
setprop net.dns1 8.8.8.8
adb tcpip 5556 (or whatever port you used earlier)
exit
exit

Your VM is now set up for network and ADB access. At this point I suggest taking a snapshot of the device by going to the “Machine” menu and selecting “Take Snapshot”. Also remember when powering off the VM to select “Restore current snapshot ‘Snapshot Name’”, so that your VM is always fresh.

If you now open up a command-line on the host, you can type in adb connect 127.0.0.1:5556 and you should successfully connect to your VM. You will have to do this each time you start your VM, but I don’t think it’s a big deal. Running your app within Eclipse will now work as expected and launch inside your VM, at much better speeds than before ;)

Finally, to make this setup perfect, right click on your VM inside the Manager and select “Create Shortcut on Desktop”. Now you should be able to start a fresh Android VM in well under 10 seconds (takes about 3 on my PC) and be ready for development!

LogPixels DPI hack

zane.a@demonastery.org (Zane Ashby) — Wed, 04 Jan 2012 00:00:00 +1300

Here’s a handy tip for those netbook users out there in dire need of more screen estate. You can force a DPI value of lower than 96 by using the Windows registry. To do so open regedit, navigate to HKEY_CURRENT_CONFIG/Software/Fonts/LogPixels and change the decimal value from 96 to something lower such as 80. Then log out and back in and you will see the changes. I’m using a value of 80 on my netbook and it is about the most that I will drop it while still keeping things (half) readable. You will notice that it really hinders the readability of fonts as well as having some strange bitmap scaling artifacts, but if you’re like me and can adjust to it then the extra screen space gained is well worth it :)

You can view a side by side comparison of the my desktop with LogPixels at 80 and at 96 by viewing this imgur album.

Docstrings in my Chicken?

zane.a@demonastery.org (Zane Ashby) — Sun, 13 Nov 2011 00:00:00 +1300

Here’s a little bit of amateur code to enable the use of docstrings in Chicken Scheme. I haven’t written any Scheme in a few months and don’t have any formal training in the ninja art of explicit renaming macros so I’d appreciate any feedback from Scheme veterans:

;;; Docstrings for Chicken!

;; The hash-table that will contain the procedures and their associated
;; documentation strings as well as their code for later use.
(define *documentation-hash-table* (make-hash-table))

;; Documented define er-macro
(define-syntax (define* form r c)
  (let* ((args-form (second form))     ; (proc args)
         (proc-name (first args-form)) ;  proc
         (doc (third form))            ; "The docstring"
         (body (drop form 3)))         ; (everything else)
    (hash-table-set! *documentation-hash-table* proc-name (list doc body)) ; insert the doc and code body
    `(,(r 'define) ,args-form ,@body))) ; Define the procedure as normal

;; Example of a documented procedure, will print a nice-ish list of documented procedures
(define* (print-docs)
  "Print a list of documented procedures"
  (hash-table-walk *documentation-hash-table*
    (lambda (key val)
      (printf "~a => ~a~n  ~a~n~n" key (first val) (second val)))))

Another example of why Scheme is such a fun language to work with :)

Twitter's Bootstrap

zane.a@demonastery.org (Zane Ashby) — Fri, 04 Nov 2011 00:00:00 +1300

To me, one of the most annoying parts of prototyping a new web application is getting a presentable look and feel up quickly. When I’m prototyping stuff I love to have a good looking interface from the start, even if that interface will be changed before going live.

Recently, Twitter released a wonderful CSS/JS framework named Bootstrap for this exact purpose. As stated it is a toolkit “[…] designed to kickstart development of webapps and sites.”. It combines an aesthetically pleasing base styling (based somewhat off of Twitter itself) of HTML elements with an easy to use CSS grid, great browser compatibility, and various optional Javascript modules to extend functionality of things such as Drop-down menus and modal dialogs.

As for the elements it offers, some of my favourites are:

All typical HTML elements are styled, including decent typography
A top bar to be used for menus and such, with drop-down menus to be activated easily with JS
Tabs/Pills
Ability to pretty-print code when used in conjunction with google-code-prettify
Labels and buttons, with styles for success, warning, notice, etc
Alert boxes, with corresponding styles, great for showing form submission status etc

Bootstrap is built on top of the LESS CSS preprocessor for ease of extending and integrating into your apps. Personally I found that the precompiled stylesheet was more than enough to begin with however, and I’m more of a fan of the SASS preprocessor anyway. The JS modules are also very easy to integrate with very little code needed to hook them up to their appropriate classes.

I jumped into Bootstrap shortly after its release, and have been using it ever since for my internal prototypes and eventual applications, including an application in the process of being deployed. Bootstrap played an integral part in getting that project complete under it’s tight deadline.

Highly recommended to all!

Das Keyboard Ultimate

zane.a@demonastery.org (Zane Ashby) — Wed, 12 Oct 2011 00:00:00 +1300

I took the plunge recently and bought my first mechanical keyboard, the Das Keyboard Ultimate. It was very hard to find someone that would ship one to NZ, but eventually I found AusPCMarket that ships the Das as well as several other “clicky keyboards”. The Das is known for being a bit pricey.. the Ultimate set me back $230NZD (incl shipping and GST) at the current exchange rate and was delivered in just over a week. If you need to justify the price by thinking of it as an investment, then do :)

With it being my first mechanical keyboard I’m unable to give a fair review in comparison to others of its kind. My previous keyboard was a Microsoft Comfort Curve 2000 keyboard (a much cheaper $40NZD), a brilliant keyboard but of course based around rubber dome technology.

Anyway, it took me a while to adjust to the non-curved layout of the Das, but now that I have I feel that I am touch-typing much MUCH more efficiently than before. It feels great to type on, plus it sounds amazing! Personally I revel in the sound of the Das, and while I wouldn’t want to use one around sleeping people, it certainly won’t break through any music playing on your headphones and so far doesn’t seem to penetrate walls ;)

Overall a definite thumbs-up from me. If you’re in NZ and looking to get a Das, I’d highly recommend also going through AusPCMarket as their service was quick and no-bullshit.

Since posting this MightyApe.co.nz has become an official Das Keyboard stockist, so NZers can save a few bucks by grabbing it from there. I also managed to pour coffee through my Das very shortly after getting it, but after flushing it out with water it is still clicking away like nothing ever happened, WIN!.

Tiny Memcached Wrapper

zane.a@demonastery.org (Zane Ashby) — Fri, 12 Aug 2011 00:00:00 +1200

No posts in a while huh! Been pretty busy and haven’t thought of much to blog about lately. But I’ve been playing with Memcache and wanted to share a tiny class I made to add easy caching to my PHP projects. This PHP class just provides a nice simple interface to use by extending the Memcached class:

<?php
// Call the class whatever you want
class MyCache extends \Memcached {
    function cache($key, $time, $func) {
        if (($val = $this->get($key)) === false) {
            $val = $func();
            $this->set($key, $val, strtotime($time) - time());
        }
        return $val;
    }
}

And now to use it, first you summon it in the same way as the regular class:

<?php
$c = new MyCache;
$c->addServer('127.0.0.1', 11211);

Then where you would like to begin caching (I’m using this very blog as an example, where GeSHi for syntax highlighting is the main bottle-neck for page generation), you call the class like so:

<?php
// Example using my BLACK blog engine (http://github.com/ZaneA/BLACK)

// Here is the original line
$row['body'] = render($row['body']);

// And here is a cached version
// As you can see we have a KEY, a TIMEOUT, and a FUNCTION to call for a cache miss
$row['body'] = $c->cache("blog_post_{$row['id']}", '30 minutes', function () use ($row) {
    return render($row['body']); // Renders all the post filters, including syntax highlighting
});

Awesome, for this small tweak on my local test blog (with 4 posts), this takes the page response time down from 14ms to 2ms. Quite a win I’d say :)

Of course this code requires the memcached PHP extension and a running Memcache server ;)

Emacs Tip: Vimpulse

zane.a@demonastery.org (Zane Ashby) — Thu, 07 Jul 2011 00:00:00 +1200

One thing I love about Emacs is that it is so extensible. I was an avid Vim user for a long time and it took me several tries to switch to Emacs, but I will never look back. With the Vimpulse addon to the built-in viper-mode, Emacs becomes a powerful Vim impersonator, capable of being extended with Emacs-Lisp.

A lot of my time is spent doing web development, and so strong HTML editing ability is essential in any editor I use. Vim has this amazing concept of text objects which allows you to be very efficient when transforming text; one of the most useful when doing web development is therefore the XML/HTML tag text object. I would use this all the time by invoking cit to change text between a pair of tags. To demonstrate, here’s a piece of text you might have sitting in a file:

<title>Hello |World</title>

Now with the cursor somewhere in between the tags (visualized above by the pipe, ’|’) we can go into command mode and type cit and the above will be replaced with:

<title>|</title>

Ready to be edited!

Well sadly, Vimpulse doesn’t have this feature by default, probably one of the very few parts of Vim that it doesn’t emulate in fact! (NB. Evil contains emulation for this already) But not to worry, we can just add it in! This is Emacs after all.

So how do we instruct Vimpulse to recognise another text object? Turns out it’s REALLY easy:

(vimpulse-define-text-object vimpulse-tag (arg)
  "Select a tag"
  :keys '("at" "it") ; The keys that will trigger this text object
  (vimpulse-inner-object-range ; We're basically defining a range on which to act upon
   arg
   (lambda (arg) (search-backward ">" nil nil arg) (forward-char)) ; Look to the left for a ">" character
   (lambda (arg) (search-forward "<" nil nil arg) (backward-char)) ; Look to the right for a "<" character
   )) ; and return the distance between them!

Note that this isn’t a perfect implementation, but for the purposes of this demonstration it will suffice! We can now cit and dit to our hearts content! Hail Emacs!

For a more robust implementation it may be worth looking at using sgml-skip-tag-backward and sgml-skip-tag-forward for movement instead.

Happy Hacking!

Org-mode Conky Colorizer

zane.a@demonastery.org (Zane Ashby) — Sun, 05 Jun 2011 00:00:00 +1200

Just whipped up a little script to colorize my org-mode todo lists for display via Conky. It’s bound to be of use to someone so I thought I’d better share :)

Here’s a screenshot of it in action, sitting in the corner of my desktop.

Source is below, to use, place ${execp /path/to/org-conky-parser.scm 30} in to your conkyrc. Requires Chicken Scheme, and remember to chmod +x the script first.

#!/usr/bin/csi -script
;; org-conky-parser.scm
;; Run an org-mode file through some regexes and output colors
;; Suitable for Conky.

; File to read, could be easily grabbed from argv
(define *file* "~/org/day.org")
(define *font* "Liberation Sans")

;; Code below

(use regex-literals)
(set-read-syntax! #\/ read-regex-literal)

(define ++ string-append)

(define (color c)
  (++ "${color " c "}\\1${color}"))

(define (font f)
  (++ "${font " f "}\\1${font}"))

(define *replace-list*
  (list
   (list /^(\*+)/      (color "#555555"))
   (list /(TODO)/      (color "#ffaa88"))
   (list /(DONE)/      (color "#aaff88"))
   (list /(TODO|DONE)/ (font (++ *font* ":style=bold:pixelsize=12")))
   (list /(<.*>)/      (color "#aaaaff"))
   (list /(<.*>)/      (font (++ *font* ":style=bold:pixelsize=14")))
   (list /(.*list.*)/  (font (++ *font* ":style=bold:pixelsize=16")))))

; Grab file contents into a list
(define *contents*
  (with-input-from-file *file* read-lines))

; Colorize a line using above regexes
(define (colorize-line line)
  (for-each ; Foreach regex/replacement
   (lambda (pair)
     (set! line (string-substitute (car pair) (cadr pair) line)))
   *replace-list*)
  line)

(define print-colorized-line (compose print colorize-line))

; Print colorized lines
(for-each print-colorized-line *contents*)

Adding FreeType to our Demo

zane.a@demonastery.org (Zane Ashby) — Sun, 05 Jun 2011 00:00:00 +1200

Continuing on from my Chicken Scheme, and OpenGL tutorial, I’m going to show you how to extend it to render pretty FreeType text using the FTGL library. Follow the code below for details as always; it’s really easy! :)

Users of ArchLinux can get FTGL with a simple sudo pacman -S ftgl. Debian should be something like sudo apt-get install libftgl-dev.

Alright lets start by loading up the code from last time …

… and scrolling down to the “(inline ..” call:

(inline #<<EOF
#ifndef CHICKEN
...
#endif

// Here we're going to add the new stuff for FTGL!

// Define a constant we're going to use later
const int FTGL_RENDER_ALL = 0xffff;

// And typedef FTGLfont as void so we can use it and pass it around
typedef void FTGLfont;

// Notice however that I didn't include the ftgl header, because I
// want to define just the functions we're going to use to make
// things even easier

FTGLfont* ftglCreatePixmapFont(const char*);

void ftglSetFontFaceSize(FTGLfont*, int, int);
void ftglRenderFont(FTGLfont*, const char*, int);
void ftglDestroyFont(FTGLfont*);

// The above are the only ones we will be using for now, but these
// ones below may also be useful, along with the SimpleLayout class

// Also possible to use ftglCreateTextureFont and
// render as a plain texture too! Using the same render call
//FTGLfont* ftglCreatePixmapFont(const char*);

//float ftglGetFontLineHeight(FTGLfont*);
//void ftglGetFontBBox(FTGLfont*, const char*, int, float*);

// Done!

… Now skip down to the EOF part:

EOF
"-lSOIL -lftgl" ; Notice here we have added -lftgl to be linked
)

… Now skip down to our old draw-text function, where we’re going to replace the GLUT code with our new FTGL render code:

(define (draw-text text x y #!key (color '(1 1 1 1)))
  (apply gl:Color4f color)
  (gl:PushAttrib gl:ENABLE_BIT)
  (gl:Disable gl:TEXTURE_2D)
  (gl:RasterPos2f x y)
  ; This line has been replaced with a new one for FTGL
  ; FTGL even takes care of rendering for us!
  (ftglRenderFont font text FTGL_RENDER_ALL)
  (gl:PopAttrib))

… and down a bit further to where we loaded the texture last time:

(define texture (LoadGLTexture "circle_gradient.tga"))

; And add a new line for loading the font up
(define font (ftglCreatePixmapFont "pathtoyourfont.ttf"))
; with minimal error checking
(unless font
  (error "Couldn't load font!")
  (exit 1))

; now set the font size
(ftglSetFontFaceSize font 36 36)

… Nearly done! down to the last line now:

(glut:MainLoop)

; Add a call to destroy the font after we're done
(ftglDestroyFont font)

And that’s it! Ah the joys of libraries and high level languages! If all went well you should have sweet anti-aliased variable-pitch text in place of the standard GLUT stuff before :D

Org-agenda-sms.el

zane.a@demonastery.org (Zane Ashby) — Thu, 12 May 2011 00:00:00 +1200

So my warmup for today was to rewrite my old org-mode agenda notification code to use Emacs lisp instead of Python. The aim of this code is to check your org-mode agenda for any headings with DEADLINEs and create a vcalendar for each, and then send them to your phone via Clickatell.

To use it, save the code into your Emacs lib path, and then in your .emacs you’ll want something like:

(require 'org-agenda-sms)

(setq org-agenda-sms-username "")
(setq org-agenda-sms-password "hunter2")
(setq org-agenda-sms-api-key "")
(setq org-agenda-sms-phone "")

(run-at-time "7am" nil 'org-agenda-sms)

The contents of org-agenda-sms.el is below:

;;
;; Org-agenda-sms.el
;; Allows Emacs to SMS you a vcalendar of appointments each day
;; Written by Zane Ashby (http://www.demonastery.org)
;;
;; Usage: (run-at-time "07am" nil 'org-agenda-sms)
;;

(defvar org-agenda-sms-username nil "Clickatell username for SMS")
(defvar org-agenda-sms-password nil "Clickatell password for SMS")
(defvar org-agenda-sms-api-key nil "Clickatell API key for SMS")
(defvar org-agenda-sms-phone nil "Phone number for SMS")

;;;###autoload
(defun org-agenda-sms-build-vcal (header timestamp)
  "Builds a vcalendar from a header and timestamp"
  (let ((vcal-template "BEGIN:VCALENDAR
VERSION:1.0
BEGIN:VEVENT
CATEGORIES:APPOINTMENT
DTSTART:%s
DTEND:%s
SUMMARY:%s
DESCRIPTION:%s
END:VEVENT
END:VCALENDAR")
        (time (format-time-string "%Y-%m-%d %H%M"
               (apply 'encode-time (org-parse-time-string timestamp)))))
    (format vcal-template time time header header)))

;;;###autoload
(defun org-agenda-sms-send (text &optional type)
  "Send an SMS vcalendar provided by \"text\""
  (let* ((text (url-hexify-string text))
         (url-format "https://api.clickatell.com/http/sendmsg?user=%s&password=%s&api_id=%s&to=%s&msg_type=%s&text=%s")
         (url (format url-format org-agenda-sms-username org-agenda-sms-password org-agenda-sms-api-key org-agenda-sms-phone (if type type "SMS_NOKIA_VCAL") text)))
    (message "Retrieving api.clickatell.com/http/sendmsg..")
    (url-retrieve-synchronously url)))

;;;###autoload
(defun org-agenda-sms ()
  "Check for appointments in org-agenda and SMS as vcalendar to phone"
  (org-map-entries
   (lambda ()
     (let ((heading (clean-org-heading (nth 4 (org-heading-components))))
           (props (org-entry-properties)))
       (cond
        ((assoc "DEADLINE" props)
         (org-agenda-sms-send (org-agenda-sms-build-vcal heading (cdr (assoc "DEADLINE" props)))))
        ((assoc "SCHEDULED" props)
         (org-agenda-sms-send (org-agenda-sms-build-vcal heading (cdr (assoc "SCHEDULED" props)))))
        ((assoc "TIMESTAMP" props)
         (org-agenda-sms-send (org-agenda-sms-build-vcal heading (cdr (assoc "TIMESTAMP" props))))))))
   "TIMESTAMP<=\"<+1d>\"|DEADLINE<=\"<+1d>\"|SCHEDULED<=\"<+1d>\""
   'agenda))

(provide 'org-agenda-sms)

Seems to work for me, but as always your mileage may vary ;)

More Practical Chicken

zane.a@demonastery.org (Zane Ashby) — Thu, 12 May 2011 00:00:00 +1200

As I love sharing code on my blog, and I love Chicken Scheme, I’m going to share a couple of handy and practical features that I’ve made use of recently.

Anyone that has used C++ for longer than a few minutes has probably noticed that literal constants (numbers and such) often have a suffix attached to them. The most common place that you’ll see this is when writing floating-point decimals, ie. 1.0f.

They might seem a little pointless at first, but they have their uses; I swear that I once read of a way to add your own types into the language too.

But anyway, I searched for a way to do this in Chicken too, and it turns out it’s really easy (of course!). Chicken provides a function called set-parameterized-read-syntax! that can emulate this functionality quite nicely.

Here’s a real world case that I used recently, I wanted to be able to convert from inches into pixels, based on a known DPI (in this case 180). The code to set this up looks like this:

; This lets you type #12i anywhere in your code and have it replaced with 2160
(set-parameterized-read-syntax #\i (lambda (port n) (* n 180)))

Yeah that’s really it, isn’t Scheme wonderful :P

The other really useful feature is the regex-literals egg (download it with sudo chicken-install regex-literals), which gives Chicken Scheme the ability to use Ruby/Perl/Javascript style literal regexes; well almost, it allows you to type #/myregexhere/i (notice the leading #) and it will be converted into a regexp object. Luckily we can even take this a step further and remove the hash at the front. Code time!

; Import the egg first of all
(use regex-literals)

; Lucky for us, regex-literals provides us the function we need to read
; a full regex literal from a Scheme port, so all we have to do is just
; hook it up to the "/" character and it will work as expected!
(set-read-syntax! #\/ read-regex-literal)

; Now we can write inline regex with a familiar syntax :D
(pp (string-match /.*match[A-Za-z]+me.*/i "hello match world me :D"))

I know this a measly amount of code to be posting an entry for, but I hope that both of these features (among others) demonstrate just how practical Chicken Scheme can be in many situations, and shows that you don’t always have to write a large amount of code to get cool things done! Mint!

FileTools C++ Class

zane.a@demonastery.org (Zane Ashby) — Sun, 08 May 2011 00:00:00 +1200

Here is the source for the FileTools C++ Class promised a few posts back, which uses inotify to monitor files for changes.

Again we start off with the class header:

// FileTools.cpp

#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>

typedef class FileTools {
public:
    static int addWatch(char *, ...);
    static void removeWatch(int);
    static bool hasChanged(int);

private:
    static int fd;
} *pFileTools;

// Parse variable arguments into 'buffer' character array
// This is just a macro I use often in my functions
#define parsevargs(buff, buffer)                    \
	char buffer[128];                               \
	memset(buffer, 0, sizeof(buffer));              \
	va_list ap;                                     \
	va_start(ap, buff);                             \
	vsnprintf(buffer, sizeof(buffer), buff, ap);    \
	va_end(ap);

And on to the implementation:

int FileTools::fd = 0;

int FileTools::addWatch(char *path, ...)
{
    // Parse variable arguments into "buffer"
    parsevargs(path, buffer);

    // Initialize inotify if need be
    if (!FileTools::fd) FileTools::fd = inotify_init();

    printf("Adding Watch for %s..\n", buffer);

    // Return a new watch handle
    return inotify_add_watch(FileTools::fd, buffer, IN_CLOSE_WRITE);
}

void FileTools::removeWatch(int wd)
{
    printf("Removing Watch id = %i..\n", wd);
    inotify_rm_watch(FileTools::fd, wd); 
}

#define EVENT_SIZE (sizeof(struct inotify_event))
#define BUF_LEN    (1024 * (EVENT_SIZE + 16))
bool FileTools::hasChanged(int wd)
{
    bool ret = false;
    
    // Return from select immediately if none available
    struct timeval time;
    time.tv_sec = 0;
    time.tv_usec = 0;
    fd_set rfds;

    FD_ZERO(&rfds);

    // Set up our fd_set with our inotify fd
    FD_SET(FileTools::fd, &rfds);

    // Do the select
    select(FileTools::fd + 1, &rfds, NULL, NULL, &time);

    if (FD_ISSET(FileTools::fd, &rfds)) {
        int length = 0;
        int i = 0;
        char buffer[BUF_LEN];

        length = read(FileTools::fd, buffer, BUF_LEN);

        while (i < length) {
            // Got a match
            struct inotify_event *event = (struct inotify_event*)&buffer[i];

            if (event->wd == wd &&
                event->mask & IN_CLOSE_WRITE) {
                // It was a file we were monitoring!
                printf("Watched file %i has changed\n", wd);
                ret = true;
            }

            i += EVENT_SIZE + event->len;
        }
    }

    return ret;
}

And that’s it! Use to your hearts content, this code and the CodeTools code before it are free to use for whatever purpose you want.

Sorry for the short post, but I want to post more Scheme (and maybe PHP) instead of cluttering up my blog with C++ ;)

CodeTools C++ Class

zane.a@demonastery.org (Zane Ashby) — Sat, 07 May 2011 00:00:00 +1200

As promised a couple of posts back, I will present a C++ class to compile some arbitrary code using GCC and load it into memory.

The code is pretty simple, we start off with the class header:

// CodeTools.hpp

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

typedef class CodeTools {
public:
    static bool compileString(char*, bool (*callback)(void*));
    static bool compileFile(char*, bool (*callback)(void*));

private:
} *pCodeTools;

And then on to the compileString method. This method actually just wraps compileFile to avoid code duplication, so it’s really just taking in a string and writing it to a temporary file before calling compileFile.

Here we go:

// CodeTools.cpp

bool CodeTools::compileString(char* code, bool (*callback)(void*))
{
    // Generate a temporary file name
    // (There are better ways to do this!)
    char temp[256];
    sprintf(temp, "codetools_XXXXXX");
    char* tmppath = mktemp(temp);

    // Open temporary file
    FILE* fp = fopen(tmppath, "wb");

    if (!fp) {
        fprintf(stderr, "Could not open temporary path %s\n", tmppath);
        return false;
    }

    // Write out string
    fwrite(code, strlen(code), sizeof(char), fp);
    fclose(fp);

    // Call out to compileFile method
    bool ret = compileFile(tmppath, callback);

    // Remove temporary file
    unlink(tmppath);

    return ret;
}

So again, just a small wrapper, which can be reimplemented to your liking.

Now for the part that does the actual work, this can be cleaned up plenty but seems pretty stable for me:

bool CodeTools::compileFile(char* path, bool (*callback)(void*))
{
    // Increments each time this function is called.
    // This is used for the .so path. If the .so path
    // doesn't change then our new functions won't
    // override the old ones.
    static int count = 0;

    // A buffer to hold our command line
    char buffer[256];
    memset(buffer, 0, sizeof(buffer));

    // The last path used
    char sopathLast[256];
    memset(sopathLast, 0 , sizeof(sopathLast));

    // The current path to use
    char sopath[256];
    memset(sopath, 0 , sizeof(sopath));

    sprintf(sopathLast, "./%s.%i.so", path, count - 1);
    sprintf(sopath, "./%s.%i.so", path, count++);

    // Please change modify these to your liking! These are what I use
    // for my livecoding playground
    sprintf(buffer, "g++ -shared -o %s -fPIC -fno-use-cxa-atexit -xc++ -include src/Global.hpp %s -Isrc -I/usr/include/freetype2", sopath, path);

    // Call it!
    int ret = system(buffer);

    if (ret != 0) {
        fprintf(stderr, "Error in compilation: g++ returned %i\n", ret);
        return false;
    }

    // Cool, compile was successful!

    // Now, try to get a handle to the last opened .so so we can close it
    void* handle = dlopen(sopathLast, RTLD_LAZY | RTLD_NOLOAD);
    if (handle) {
        fprintf(stderr, "Found current handle %s, closing first\n", sopathLast);
        dlclose(handle);
    }

    // Open the new .so, LAZY load symbols for speed
    handle = dlopen(sopath, RTLD_LAZY);

    if (!handle) {
        fprintf(stderr, "Could not load compiled file into memory: %s\n", dlerror());
        unlink(sopath);
        return false;
    }

    printf("Loaded %s\n", sopath);

    // Remove temporary .so
    unlink(sopath);

    // Call the user supplied callback passing the .so handle to it
    // From there it can load individual functions.
    return callback(handle);
}

And done. This should be all the code needed to use the CodeTools sample from the C++ Eval? Hell yes. post. Have fun! I will be posting the FileTools class shortly too.

Fun with Renoise and Fluxus

zane.a@demonastery.org (Zane Ashby) — Mon, 02 May 2011 00:00:00 +1200

Amidst my experimentations with livecoding I decided to purchase the amazing Renoise Tracker (and overall DAW) while it is on special (30% discount!). My intentions are to play around with Renoise to make music (online and off), and using the built in OSC and JACK support, coordinate the music using Fluxus, and of course be able to respond to it. I am also toying with the idea of using an Arduino or two as input devices. Fun stuff I reckon :P

For anyone wondering how to make Fluxus respond to the Renoise audio, it is simple using JACK:

; If I remember correctly you may need to connect the Renoise
; output to the Fluxus input using something like qjackctl first

(start-audio "renoise:output_01_left" 1024 44100) ; This will tell Fluxus to listen to the left channel..
(gain 1)

; .. and later in your render loop, using the "gh" function you can react to the sound
(every-frame
  (begin
    (scale (vmul (vector (gh 1) (gh 2) (gh 3)) 0.1))
    (draw-torus)))

Pretty neat. Using OSC it is also really simple to control Renoise. First you will want to enable the OSC server in the Renoise preferences, and then you can use the following:

(osc-destination "osc.udp://localhost:8000") ; With the port you specify in the preferences
(osc-send "/renoise/song/bpm" "i" (list 120)) ; Set the BPM to 120
(osc-send "/renoise/transport/start" "" (list)) ; Start playback
(osc-send "/renoise/transport/stop" "" (list)) ; Stop playback

Next up is to get Fluxus working nicely with Emacs.. and I promise some more updates will come shortly (including the code I’ve promised) :)

C++ Eval? Hell yes.

zane.a@demonastery.org (Zane Ashby) — Sat, 16 Apr 2011 00:00:00 +1200

Recently I’ve been getting back into live coding, and as part of that I have been experimenting with a simple livecoding framework in C++.

One of my experiments involves using C++ as a scripting language, by compiling code on the fly (using g++, but any compiler should work) into a shared object, and then dlopen-ing the resultant file and hooking up the necessary functions.

By doing this I can have full access to the engine/framework and speed is never a concern. It also means I can modify it later to load any arbitrary shared object (ie. generated via C or any other language, perhaps Chicken?).

The workflow I desired to achieve was to have an OpenGL context open, blank at first. From there I could open the editor of my choice, hack on some high level C++/OpenGL, and when I saved the file, the engine would recompile the file and load it, causing its rendering function to be overridden with the new one.

I’m happy to say I’ve achieved what I was after!

I will be posting the relevant source to do this in the next post, but for now I will say that it involves a very simple class called FileTools that wraps inotify on the Linux operating system (so it will need to be ported for other OS’s, or a generic polling solution could be used very easily, by simply resorting to stat)), which allows one to watch a file with some simple code that looks like this:

int fd = FileTools::addWatch("test.cpp");

while (mainloop) {
      if (FileTools::hasChanged(fd)) { // Uses select internally
         // Cool!
      }
}

FileTools::removeWatch(fd);

For my engine to extend this to include recompilation, I have another class called CodeTools, which wraps system and dlopen. This is also very easy to use, it looks like this:

if (FileTools::hasChanged(fd)) {
   CodeTools::compileFile("test.cpp", [](void* handle) {
      Renderer::renderp render = (Renderer::renderp)dlsym(handle, "render");
      if (render) // Hook 'er up
         ::engine.renderer->userRender = render;
   });
}

Here we are passing a path to a file to compile, and a function (I’m using C++0x lambdas here) that takes a valid handle from dlopen.

Using this class it is also possible to using compileString to compile a string via temp files.

Oh and a screenshot for those wanting to see it in action!

Change GTK display on the fly

zane.a@demonastery.org (Zane Ashby) — Sat, 09 Apr 2011 00:00:00 +1200

While working on my netbook away from my desktop machine, I pondered how I could view my email clients display (claws-mail, a GTK app), without having to resort to something such as VNC.

I know this can be done using utilities such as xmove, which essentially act as a proxy X server that can detach a client from one display and move it to another. But this requires you to start xmove before the application, and to tell the application to launch with its display on xmove.

Nah. We need something cooler than this.

After using some Google fu it became apparent that the GTK library has a function named gtk_window_set_screen which is demonstrated in the gtk-demo application that comes with the GTK sources. This function allows the application to switch X11 display on the fly.. provided the application has a way to do so (which barely any do, apart from the GIMP, because most don’t need to).

So I decided to look into ways of doing code injection in Linux, as a way of being able to call that function inside our target application. Turns out this is easy as pie using GDB.

First of all, we need to create a small library that contains our code. This will be loaded into memory and executed by us later. The code I hacked together looks like this (no guarantees whatsoever that this will work on your machine):

// Include the headers we will need
#include <stdio.h>
#include <gtk/gtk.h>

// Now write the function we will be executing.
// This one takes a string containing the display to connect to
void change_display(char *display_str)
{
  GdkDisplay *display = gdk_display_get_default();
  GtkWidget *toplevel = NULL;

  GdkWindow *window = NULL;
  GtkWidget *widget = NULL;

  // Not 100% necessary but gives you time before the line below this one runs
  sleep(5);
  
  // This line gets the GDK window below the cursor
  window = gdk_display_get_window_at_pointer(display, NULL, NULL);
  if (window) {
      gdk_window_get_user_data(window, (gpointer)&widget);

      toplevel = gtk_widget_get_toplevel(widget);

      GdkDisplay *new_display = gdk_display_open(display_str);
      if (new_display)
          gtk_window_set_screen(GTK_WINDOW(toplevel), gdk_display_get_screen(new_display, 0));
      else
          fprintf(stderr, "Could not connect to display \"%s\"\n", display_str);
  } else {
      fprintf(stderr, "No window found\n");
  }

  // By this point the window should have moved itself to the display you passed in
}

Cool. So now we just need to compile it and we’re a step closer to winning:

gcc -shared -fPIC -o lib lib.c `pkg-config --libs --cflags gtk+-2.0`

Now we should be left with our library sitting in our current directory. Now we can actually inject the code. For this part, we will fire up GDB, attaching to the program we wish to move:

gdb attach `pidof claws-mail`

A bunch of lines will scroll by, which you can largely ignore for this exercise, but you should be left with a nice (gdb) prompt. Now it’s time to inject our code!

(gdb) print (void*)dlopen("/path/to/your/current/directory/lib", 2)

Yep, GDB has now loaded our library into the memory space of the application. Now we can run our function :)

(gdb) print change_display("192.168.1.2:0")

If we now quickly move our cursor over to the window of the application. After a few seconds the window should successfully move to the proper display.

Pretty easy huh? :D There are plenty more things you can achieve with simple code injection like this, and for the purpose of this exercise, we could have written a GTK module instead. But this is just cool.

Mimicking Threading in PHP

zane.a@demonastery.org (Zane Ashby) — Sun, 03 Apr 2011 00:00:00 +1300

People often criticize PHP for not having the ability to use threading), which is a fair point and quite often a drawback. Here I am presenting a method for mimicking threads through forking) of the PHP interpreter. This may not work as well on a Windows system since AFAIK forks are more expensive there than on unix (I would love to be proven wrong however!). You will also need to make sure that you have the extension=sockets.so somewhere in your php.ini.

The code is very simple and short, it works using socket IPC and PHP serialization:

<?php
function async($thunk) {
    // By creating a socket pair, we have a channel of communication
    // between PHP processes
    socket_create_pair(AF_UNIX, SOCK_STREAM, 0, $sockets);

    list($parent, $child) = $sockets;

    if (($pid = pcntl_fork()) == 0) { // We're in the child process now
        socket_close($child);
        // Call the thunk, serialize the returned value, and send it
        // through the channel we created (ie. to the parent process)
        socket_write($parent, serialize(call_user_func($thunk)));
        socket_close($parent);

        exit; // We're done so we can exit here
    }

    socket_close($parent);

    return array($pid, $child); // This can treated as a "thread handle"
}

function wait($proc) {
    pcntl_waitpid($proc[0], $status); // Wait for the process to finish

    // Read the data from the channel, and then unserialize it into
    // a PHP object that can be returned
    $output = unserialize(socket_read($proc[1], 4096));
    socket_close($proc[1]);

    return $output;
}

And to use it is just as simple:

<?php
$thread = async(function () {
    // Note that variables can be passed through with the "use" construct
    // (ie. $thread = async(function() use($local_var) { ...

    sleep(2); // to show that we really are running asynchronously

    echo "Hello from Child Thread!\n";

    return array('hello', 'world!');
});

echo "Hello from Main Thread\n";

$output = wait($thread);

print_r($output);

// Prints:
//
// Hello from Main Thread
// (and then 2 seconds later)
// Hello from Child Thread
// Array
// (
//     [0] => hello
//     [1] => world!
// )

Feel free to rip this and use it in your own projects! The original code was pulled out from my ProtoIRC framework, a small framework for prototyping IRC bots and utilities.

Chicken Scheme, and OpenGL

zane.a@demonastery.org (Zane Ashby) — Sat, 02 Apr 2011 00:00:00 +1300

Today I’m posting an example of how you can quickly get started with OpenGL using Chicken Scheme.

I am posting the code in full, but I have commented it pretty well and so everything should be quite simple to understand.

Unless you take out the texture rendering, you will probably want to get SOIL for your distribution (Archers can get it with sudo pacman -S soil).

;;;
;;; Lets make a simple OpenGL application using Chicken Scheme!
;;; Thanks to all the egg authors and Chicken Scheme contributors for making this awesomeness possible!
;;;

;; Firstly, lets include the eggs that we will use.
;; These are the OpenGL and GLUT eggs (for display),
;; and the Inline egg (described below).
;; These can each be installed using the "chicken-install" command

(use gl glut inline)

;; Now we will define some variables that we will reference later in our code

(define screen-w 800)
(define screen-h 600)

(define mouse-x 0)
(define mouse-y 0)

(define background-color '(0 0 0 0))


;; Using the wonderful inline egg, we can embed some C code directly into the
;; Scheme source and it will be compiled, cached and bound automatically, even
;; while using the interpreter! We're going to use this functionality to add
;; the ability to load textures into OpenGL using the wonderful SOIL library

;; Protip: If you select the lines inside inline in Emacs, you can use the
;; M-x narrow-to-region to show just the C code, and if you use M-x c-mode you
;; can even edit with your regular C keybindings. When you're done just use
;; M-x widen and then M-x scheme-mode to get back to normal. Emacs is awesome!

(inline #<<EOF
// The define guard stops Chicken from trying to read and parse SOIL.h
#ifndef CHICKEN
#include <SOIL.h>
#endif

// A simple wrapper to load an OpenGL texture using SOIL with sane parameters
unsigned int LoadGLTexture(char *path) {
    return SOIL_load_OGL_texture(path, SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID,
                                 SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_INVERT_Y |
                                 SOIL_FLAG_MULTIPLY_ALPHA | SOIL_FLAG_COMPRESS_TO_DXT |
                                 SOIL_FLAG_DDS_LOAD_DIRECT | SOIL_FLAG_TEXTURE_REPEATS);
}

// Bind the usleep function available on POSIX systems.
// on Win32 systems, the "Sleep" function is equivalent
int usleep(unsigned int ms);
EOF
"-lSOIL" ; Arguments to be provided to compiler and linker
)


;; This is one of those use cases I talked about in my call-cc article.
;; It provides the ability to break to a REPL by hitting the spacebar

(define return #f)
(define (break-to-repl)
  (printf "~nType (return) to resume rendering~n")
  (call/cc
   (lambda (k)
     (set! return (lambda () (k #f)))
     (repl))))


;; Now we're going to define two simple functions that can be used when 
;; coding our demos in OpenGL. This includes basic text display and the
;; drawing of a textured quad. Pretty simple but should serve as a good
;; starting point for creating your own stuff!

(define (draw-text text x y #!key (color '(1 1 1 1)))
  (apply gl:Color4f color)
  (gl:PushAttrib gl:ENABLE_BIT)
  (gl:Disable gl:TEXTURE_2D)
  (gl:RasterPos2f x y)
  ;; The cut macro is something I've only just discovered. It essentially returns a function made
  ;; from the parameters provided, however <> is replaced with the argument that is passed to it
  (string-for-each (cut glut:BitmapCharacter glut:BITMAP_8_BY_13 <>) text)
  (gl:PopAttrib))

(define (draw-quad t x y w h #!key (color '(1 1 1 1)))
  (apply gl:Color4f color)
  (gl:BindTexture gl:TEXTURE_2D t)
  (gl:Begin gl:QUADS)
   (gl:TexCoord2f 1 1) (gl:Vertex2f x y)
   (gl:TexCoord2f 1 0) (gl:Vertex2f x (+ y h))
   (gl:TexCoord2f 0 0) (gl:Vertex2f (+ x w) (+ y h))
   (gl:TexCoord2f 0 1) (gl:Vertex2f (+ x w) y)
  (gl:End))


;; Now it's time to do the actual set up. We're going to define the
;; functions we need to open the display and handle any events through
;; callback functions we give to GLUT

(define (setup-display)
  ; These lines take care of setting up the GLUT window
  (glut:InitDisplayMode (bitwise-ior glut:DOUBLE glut:RGBA))
  (glut:InitWindowSize screen-w screen-h)
  (glut:CreateWindow "Chicken Scheme OpenGL | Hit space for REPL")

  ; Enable texturing and set background color
  (gl:Enable gl:TEXTURE_2D)
  (gl:TexEnvf gl:TEXTURE_ENV gl:TEXTURE_ENV_MODE gl:MODULATE)
  (apply gl:ClearColor background-color)

  (gl:Enable gl:BLEND)
  (gl:BlendFunc gl:ONE gl:ONE)

  ; Set up a basic 2D orthogonal projection
  (gl:MatrixMode gl:PROJECTION)
  (gl:LoadIdentity)
  (gl:Ortho 0 screen-w screen-h 0 -1 1)
  (gl:MatrixMode gl:MODELVIEW))

(define (keyboard-handler key x y)
  ; If escape is pressed exit.
  ; If space is pressed then break to REPL
  (cond ((eq? key #\esc)
         (exit))
        ((eq? key #\space)
         (break-to-repl))))

(define (idle-handler)
  ; Sleep for 100 microseconds to give up CPU time
  (usleep 100)
  ; And then redisplay
  (glut:PostRedisplay))

(define (display-handler)
  (gl:Clear (bitwise-ior gl:DEPTH_BUFFER_BIT gl:COLOR_BUFFER_BIT))
  (gl:LoadIdentity)

  ;; Here's where the drawing happens, so this is probably where
  ;; you'll spend most of your time hacking around. All that
  ;; this demo does however is draw a texture that follows the
  ;; cursor around the screen.
  
  (draw-text "Hello, OpenGL World!" 10 20)

  (gl:Translatef -50 -50 0)

  (draw-quad texture mouse-x mouse-y 100 100)

  (glut:SwapBuffers))

(define (passive-motion-handler x y)
  ; Update the mouse x and y positions
  (set! mouse-x x)
  (set! mouse-y y))


;; Cool, now we're ready to run!

(setup-display)

; Load a texture
(define texture (LoadGLTexture "circle_gradient.tga"))

; Hook up GLUT events
(glut:KeyboardFunc keyboard-handler)
(glut:PassiveMotionFunc passive-motion-handler)
(glut:IdleFunc idle-handler)
(glut:DisplayFunc display-handler)

; Start the GLUT mainloop, which runs until exit
(glut:MainLoop)

Make sure you have a texture of some sort sitting in the same directory as the code. I was using circular_gradient.tga.

If you now run this using csi example.csm, you should see a window popup with some text and a simple quad that follows the mouse cursor. If you hit the spacebar the rendering will pause and you will see a REPL in the terminal you launched it from. Inside the REPL you can potentially transform the render loop and do other such fun things. As a simple idea of what you can achieve, make sure you have another texture sitting in the example directory, and then type the following in the REPL:

(set! texture (LoadGLTexture "newtexture.tga"))
(return)

If all goes well, your render loop should continue, with the old texture replaced by the new one you just loaded. Pretty nifty!

In a future follow-up to this post I will have a go at adding FreeType font rendering, and using OpenAL for sound, so stay tuned!

Acer Aspire ONE D255E

zane.a@demonastery.org (Zane Ashby) — Sun, 27 Mar 2011 00:00:00 +1300

A week ago I went searching for a small netbook. My requirements were pretty simple; it needed to be cheap, and be able to dual boot Linux and Windows 7. Because I’m in New Zealand, the first place I checked out was Dick Smith Electronics, which currently had a great special running on the Acer Aspire ONE D255E ($399 NZD, roughly $300 USD). Now the specs listed on the site were actually false, but the actual specs of the laptop are higher.

The machine uses the Intel Atom N455 processor, which is a dual core CPU running at 1.66GHz. It has 1GB of DDR3 memory, a 250GB Hard Drive (non-SSD of course), 10.1” LED LCD at 1024x600 (which is tiny, but well suited to a window manager such as ratpoison. The VGA port also handles my 1920x1080 display with no trouble), and comes with Windows 7 Starter edition. These specs seem reasonable to me, and I’m used to getting the most out of my hardware. For interest sake, the machine also has a built-in webcam, 2-in-1 card reader, 802 11b/g/n Wifi (Atheros), a Synaptics touchpad that has basic multi-touch support, and a 3-cell Li-ion battery that gives roughly 4 hours of battery life (can also upgrade to a 6-cell). This particular machine has no bluetooth, although it seems to be an optional extra (along with internal 3G), and of course no optical drive.

The first thing I did when I unboxed this machine (after installing the battery) was format the hard drive (Windows 7 starter is plenty capable, but it’s not for me). After getting a hold of an external optical drive I proceeded to install Windows 7 Ultimate on it, giving Win7 about 60GB of space, using a single partition only (there’s a trick to getting rid of the System Reserved partition, but it’s a pretty simple one). Once installed, I booted the machine up, and surprise surprise, there’s pretty much nil driver support for this thing using the built-in Win7 drivers. Even VGA was limited to 800x600. Luckily I have an extra machine on standby that I was able to use to download some drivers. Unfortunately this system is new enough that the drivers are only just hitting the net, and I wasn’t able to find the correct ones on the Acer site itself (If you want the names and download locations, ask in the comments). But after spending a couple of hours finding the correct ones, it was up and running smoothly.

Next on the list was getting Debian installed. For this I used the non-free net-install Debian Testing ISO, which is great because it includes non-free Wifi firmware. The downside is that the Debian installer doesn’t support WPA encryption, even though it is available after. So I was forced to use the ethernet port for installing. I had some issues with Grub but I think that was down to user error, not a fault of Debian itself. Debian was also given 60GB to play with, split 50/50 between / and /home.

Unlike Windows, Debian either detected or had the appropriate drivers handy after a first boot which was great. After installing X with the Intel driver, KMS appears to be working, and everything else works great including wifi (using the ath9k driver), battery, and temperature status. Suspend/resume seems to be set up correctly, although I haven’t actually tried it out yet. The Synaptics touchpad needs some tuning in Xorg.conf to work, but once that’s done it works better than it does in Windows, and you can even set up circular scrolling and coasting, yee-haw!.

Overall the system isn’t as fast as what I’m used to, but it is very capable and is perfect for what I will use it for (web development, and Scheme hacking). Plus it’s the perfect size for a CarPC (I’m in the process of writing a nice MusicPD client now) ;)

I would definitely recommend the Aspire ONE D255E to anyone else on the hunt for a cheap netbook.

While I’m at it, if anyone has some suggestions for Scheme (or PHP) tutorials they would like to see then let me know in the comments (you can see them by clicking on the post title). I love putting them together but I find it hard to decide what to write about.

A Newbie Guide to Call/cc

zane.a@demonastery.org (Zane Ashby) — Mon, 14 Mar 2011 00:00:00 +1300

I haven’t had much to write about in the last couple of weeks, but I’ve really wanted to do a small piece on the magic of call-with-current-continuation in Scheme, aka. call/cc.

For some reason I had a difficult time wrapping my head around this little statement, even though it isn’t terribly complicated at all (from an end coder perspective that is; I don’t want to imagine the headaches it causes for the compiler hackers ;)). For all intents and purposes, you can think of call/cc as a glorified return or a smart goto statement (and that is how it will sound when I try to explain it).

But first of all, what is this continuation thing?

You can think of a continuation as an object that represents the position of execution in a running program. If we call a continuation object as though it were a function, we will jump to that position in the program, and continue the flow from there.

If we want to store a continuation we call the function call-with-current-continuation (shortened to call/cc in many Scheme implementations). This function takes a single argument, of a lambda to call.. with the current continuation.. An example is below:

(print
 (call/cc (lambda (k) ; k is used as a convention for a continuation variable as far as I understand
            ; We can do whatever we want here, it's just a regular function
            ; Lets return some text
            "Hello, World")))

This example will simply print “Hello, World” to the console. Now to show the mighty magic of continuations:

(print
 (call/cc (lambda (k)
            ; Pretend we are doing some processing here,
            ; perhaps looping over a list looking for something.

            ; Now pretend that we've found what we're looking for.
            ; We are going to call the continuation with a value.
            (k "We found the value man!")

            ; And now this is placed after the loop
            "Didn't find what we were looking for."
            )))

When (k "We found the value man!") is called, we jump back to our continuation (ie. the place of (call/cc) and return the value passed to k back to print. So of course our example will print “We found the value man!” to the console.

This is pretty much all that there is to know about continuations. As you can see it is really a way to allow functional programs to terminate from a function early.

There are a wide variety of uses though, depending on how you dress up call/cc. A cool example comes from the in development Tehila Scheme game engine, which simplified looks a little like this:

;; Called when the Spacebar is hit
(define (break-to-repl)
  (printf "Type (return) to resume gameplay~n")
  (call/cc (lambda (k)
             (set! return (lambda () (k #f))) ; So the user can call (return) instead of (k #f)
             (repl)))) ; Call the built in REPL

This allows the user to hit Spacebar mid-game to get a REPL, which will pause the game. When they wish to continue, they simply enter (return) into the console, and the game continues from where it left off.

Another good use of continuations is for implementing exceptions. For example if you take the SRFI-34 (Exception Handling) egg available for Chicken Scheme, you can think of the guard construct as being call/cc, and the raise statement as being (k 'myexception).

So that’s it for my newbie guide to call-with-current-continuation. I hope this cleared it up for someone, and I hope that you now understand call/cc enough to make some cool things happen with it!

Edit: DerGuteMoritz points out in the comments that you can also call continuations more than once, and gives an example:

(define foo #f)
(display (string-append (call/cc (lambda (k) (set! foo k) "foo")) "\n"))
(foo "baz")
(foo "qux")

Which will print:

foo
baz
qux

A Scheme Infix Transformer

zane.a@demonastery.org (Zane Ashby) — Tue, 08 Mar 2011 00:00:00 +1300

As promised in the last post, I am going to share an infix function, that takes a list that looks like (1 + (2 * 3)) and turns it into (+ 1 (* 2 3)) (Prefix).

Creating this function was a perfect place to start playing with Unit Testing as well. Something that I have not used much of until now.

Unit testing is really useful in this situation. We can write a tiny test that checks if our infix/lr (lr because it parses left to right, not that it matters) function gives the appropriate result. That test will look like this:

; Load the lightweight unit testing unit
(use srfi-78)

; And write the test
(check (infix/lr '(1 + (2 * 3) + 4)) ; Check that this
       =>                            ; matches
       '(+ (+ 1 (* 2 3)) 4))         ; this

If all goes well, once the function is written the test should pass.

Here’s the complete function itself:

; Parses an infix list into a prefix list
(define (infix/lr lst)
  (when (even? (length lst))
    (error "Wrong number of arguments to infix operator"))
  (let loop ((n (first lst))
             (lst (cdr lst)))
    (if (not (null? lst))
        (loop (list (first lst) n
                    (if (list? (second lst))
                        (infix/lr (second lst))
                      (second lst)))
              (drop lst 2))
      n)))

I firmly believe this can be written to look (and probably function) better than it currently is (Edit: Using regular let instead of letrec now), but I’m still learning. Notice I also check the number of arguments; if it is an even number this means we will be missing a value at the end, since obviously we need 3 items to perform the swap (two values and an operator).

So that is the function part taken care of, and this should be perfectly usable as is, but we can take this a step further by binding it to a read macro. This part is really up to you, here’s how I do it:

And now we have an infix macro that can be used for easy calculations!

One word of warning though, this function does not take into account operator precedence (to keep it simple) and so you are required to use parentheses to enforce precedence.

And of course because we’re simply swapping lists around, it is perfectly possible to infix any scheme function that takes two arguments.

Enjoy! :)

An Intro to Scheme Macros

zane.a@demonastery.org (Zane Ashby) — Mon, 07 Mar 2011 00:00:00 +1300

In this post I want to go a little deeper into the macro system of Scheme (particularly Chicken), and share a couple of macros I’ve created.

First of all, macros are what make Scheme and Lisp so exciting. Macros offer the ability to evaluate code at compile time, and modify the structure of a program before it even runs. You can think of it as a really really powerful #define, but where #define lets you modify text, a Lisp macro lets you modify the code structure itself.

There are a couple of different kinds of macro available in Scheme, and as I’m somewhat of a young schemer I’m not completely sure which are available across all implementations and which are only available in Chicken. But I will assume that the macros here can be ported with relative ease.

The first kind, looks a lot like a regular ol’ function. It is even called like a function, only when this macro is read it leaves behind whatever it returns. Here’s an annotated example:

; Here we are going to create a new macro called "return-me"
; that will simply return in a list whatever is passed to it
(define-syntax return-me
  (syntax-rules () ; Any symbols placed in this list will be ignored
    [(return-me body ...) ; This is what the arguments should look like
     (list body ...)])) ; And this is how they should be transformed

; Example
(return-me "Hello" "World") => ("Hello" "World")

As you can see, it’s nothing terribly complicated, but it opens up a world of possibilities. Extending on this previous example, I will show you a “run” macro, which gives a nice interface to launching applications through SSH and receiving the output:

; Firstly, we need a couple of extra units loaded
(use posix regex regex-literals)

; This is a shell function which calls the supplied argument and
; returns the result in a list of lines
(define (shell args) (call-with-input-pipe args read-lines))

; The run macro itself
(define-syntax run
  (syntax-rules (as on) ; We want to ignore the words "as" and "on"
    [(run command as username on machine) ; Here is the full macro
     ; This line extracts the host and port from the "machine" part
     (let ([matches (string-match #/(.*?):(.+)/ machine)])
       (when (list? matches) ; Got some matches
             (shell (format "ssh -C -p ~a ~a@~a ~a"
                            (third matches) ; Port
                            username
                            (second matches) ; Machine
                            command))))] ; Cool, return the output
    ; Here we have a smaller version of the macro with some defaults
    [(run command on machine)
     (run command as (getenv "USERNAME") on machine)]
    ; And same again here, but avoid the SSH step in this case
    [(run command)
     (shell command)]))

; Example
(run "uname -a" as "zanea" on "pr0d:2222") => ("Linux pr0d 2.6 etc..")

So as you can see we have already created our very own (albeit small) Domain Specific Language used to describe how to run a command on another machine.

The second kind of macro I’m going to introduce is the read macro. A read macro gives you the ability to control how the Scheme reader understands syntax. A very small example follows:

; This example simply makes !sym become (not sym)
; The lambda expression is triggered whenever a "!" is encountered
(set-read-syntax #\! (lambda (port) `(not ,(read port))))

A very small example indeed, but it shows something useful.

So I hope you’ve enjoyed this small intro to Scheme Macros.. In the next episode I’ll be showing another rather simple macro that allows you to use infix expressions (ie. 1 + 2 + 3) inside your programs… stay tuned..

A Brief Foray into Haskell

zane.a@demonastery.org (Zane Ashby) — Sun, 06 Mar 2011 00:00:00 +1300

I’ve tried to learn Haskell in the past and found it completely horrible to look at. That was, until I got around to learning Scheme and decided to look deeper into it.

A couple of nights ago a friend showed me a small piece of Haskell code which reads a series of lines formatted like this:

a 1
b 2
c 3

And sums up the second column. The code looks like this:

foldl1 (+) (map (\c -> read (c !! 1)) (map words (lines "a 1\nb 2\nc 3")))

At first glance, I was at a total loss as to what was going on. So I fumbled around in ghci for a while figuring out what each part was doing.

It took me a while to realise that both words and lines are builtins, and this alone cleared the picture up quite significantly.

The other part I had major trouble with was the !!, and google was somewhat unhelpful at first, but it is basically the Haskell equivalent of

(list-ref c 1)

aka the array subscript operator.

Now it’s starting to come together in my head. The line basically reads as (from right to left):

Split the string “a 1\nb 2\nc 3” into a list of lines, and then for each of the lines, split the line into separate words. Now, for each of these lines, create a lambda that reads the list of words in the line, and “read” the second item (this causes the string “1” to become the integer 1) and return it. Finally, now that we have a list of integers, Fold them to the left using the ”+” function. The result is 6.

The translation into Scheme is quite easy too, if we define a couple of small helper functions:

(define read/s (lambda (c) (with-input-from-string c read)))
(define words string-split)
(define lines (lambda (str) (string-split str "\n")))

; Now the actual translation (which has the same number of characters as the Haskell version!)
(fold + 0 (map (lambda (c) (read/s (second c))) (map words (lines "a 1\nb 3\nc 3"))))

Just understanding this small piece of Haskell has made me curious about using it further. The idea that originally drove me away from it (the conciseness, which makes it hard to read at first), turns out to be its simplicity. Much the same as with Scheme.

Quake 2 Hacking

zane.a@demonastery.org (Zane Ashby) — Sun, 20 Feb 2011 00:00:00 +1300

Quake 2 (aka id Tech 2) is a great game and engine to hack. The source is pretty well laid out and the code is small enough that it doesn’t take forever to become familiar with it. It also has a great entity system that makes it a really suitable for prototyping.

I spent the last couple of nights stripping as much of the game code as I could out, right down to the essentials, and then stripping the game data down to the bare minimum as well. I built a plain cube map with a single info_null entity, that gets loaded on startup, acting as a gateway map. The info_null entity contains a “model” key, which loads an arbitrary md2 from disk (in this case, some couch model I found online).

Next I set about embedding Chicken Scheme into the game code as an interpreter, and a few thousand segfaults later, it works! I have output redirection and an “eval” command for the console, allowing you to type some code and get a response.

I also started on a high level API for controlling in game objects that I will just implement as I go, that looks a little like this:

(q2:fire-blaster (q2:get-player-by-name "Player"))

So for just a couple hours of work I have a decent engine and scripting language that can be built up in whatever direction I decide to go with it :D

Sawfish Theme, GperfectionHash

zane.a@demonastery.org (Zane Ashby) — Thu, 17 Feb 2011 00:00:00 +1300

Just a simple modern SawfishWM theme I made, modified from gperfection.

There is a dark version (named perfection-hash), and a light version (named gperfection-hash-light), to suit dark and light GTK themes (not included).

Font in title is “Helvetica Neue Bold 7”.

To download, head over to http://hashbox.deviantart.com/art/Gperfection-Hash-for-Sawfish-197710239.

To install, unzip inside ~/.sawfish/themes/ and select gperfection-hash(light) in Sawfish configuration.

Have fun!

Chicken Scheme, and FFI

zane.a@demonastery.org (Zane Ashby) — Mon, 31 Jan 2011 00:00:00 +1300

As a follow up on yesterdays post I’m going to show how easy it is to integrate some third party functionality in to a web application to provide “automatic tagging” using libots.

To do this, we’re going to use the Chicken FFI. Now this example is really so short that there’s no point in splitting it into multiple blocks, so here we go:

;; FFI example
(import foreign)

; Add the libots header
(foreign-declare "#include <libots-1/ots/libots.h>")

; Declare the function we're going to use
(define ots-text-topics
  (foreign-lambda c-string "ots_text_topics" c-string c-string int))

; And here's another useful one
(define ots-summarize
  (foreign-lambda* c-string* ((c-string str) (int percent))
                   "OtsArticle* article = ots_new_article();
                    ots_load_xml_dictionary(article, \"en\");
                    ots_parse_stream(str, strlen(str), article);
                    ots_grade_doc(article);
                    ots_highlight_doc(article, percent);
                    size_t outlen = 0;
                    char *text = ots_get_doc_text(article, &outlen);
                    ots_free_article(article);
                    C_return(text);"))

And now to use it (the automatic tagging part):

;; OTS tagging
(let* ((num-tags 3)
       (body "This is the post you want to tag")
       (tags (ots-text-topics body "en" num-tags)))
  (display (string-append "The tags found are: " tags)))

Now all that’s left is to compile it:

csc code.scm `pkg-config --cflags --libs glib-2.0 libots-1 libxml-2.0`

That’s really all there is to it!

Chicken Scheme, and Web RAD

zane.a@demonastery.org (Zane Ashby) — Sun, 30 Jan 2011 00:00:00 +1300

Recently I’ve taken more of a liking to Chicken Scheme, and started trying to use it for more of my day to day development. Recently I wrote a port of a JS + HTML5 Pong Clock into Chicken Scheme using the OpenGL + GLUT libraries. I couldn’t believe how smoothly it went, since it was a line by line port, the only thing I needed to write myself were the graphics drawing routines, easy enough since we’re only dealing with white rectangles after all, but now it functions as a cross platform screensaver (verified on Linux, OSX, and XP!).

But the area I spend most of my time in is web development, so I was pleased to find the Awful framework for Chicken. Despite the name it is anything but. A simple usage example looks like this:

;; Hello World!
(use awful)

(define-page "/"
  (lambda ()
    "Hello, World!"))

Yes, it really is that easy. Of course you’ll most likely want to define your own template, and that is really easy to do too, my templates look something like this:

;; Defining a template
(define-syntax define-templated-page
  (syntax-rules ()
    ((_ path body ...)
     (define-page path
       (lambda ()
         (<html>
          (<head> (<title> "Page Title")
                  (<link> rel: "stylesheet" href: "/style.css"))
          (<body>
           body
           ...
           (include-javascript "/jquery.min.js")
           (<script> type: "text/javascript"
                     "$(function () {
// jQuery goes here
});"))))
       no-template: #t))))

Which is then used like this:

;; Templated Hello World!
(define-templated-page "/"
  (<h1> "Hello")
  (<h2> "World!"))

This is a good example of how scheme macros can simplify anything and everything. It has made defining a new page as easy as adding a single line of code.

Combined with DB connectors and a multitude of other awesome libraries, Chicken Scheme and the power of macros really make for a wonderful rapid prototyping environment. With the ability to compile down to a static executable, this is my new favourite method of creating desktop applications that use a browser for presentation.

BLACK - Blog Engine

zane.a@demonastery.org (Zane Ashby) — Thu, 30 Dec 2010 00:00:00 +1300

As part of the migration of my blog to the Linode, I’ve cleaned up and restructured the code that powers this blog somewhat and made it available on Github for others to use. Right now it is there more as a reason for me to keep improving it than anything else, since it needs some work.. but hopefully it will become useful enough for someone else to use it in the future.

The “engine” revolves around the single function “post”. An example of its usage is below:

<?php black\post($query, function ($post, $issingle) { ?>
  <a href="/<?= $post['id'] ?>/"><?= $post['title'] ?></a>
  <br />
  Posted on <?= date('l, F jS Y', $post['timestamp']) ?>
  <br />
  Tags for this post are <?= $post['tags'] ?>
  <br />
  Aaaannnd the post itself:
  <br />
  <?= $post['body'] ?>
  <br />
  <?php if ($issingle): ?>
     Viewing by post id, so insert Disqus commenting stuff here perhaps?
  <?php endif ?>
<?php }) ?>

Added into an existing website template, the provided function will be called for each post you have, printing them all out to the page.

New Server

zane.a@demonastery.org (Zane Ashby) — Mon, 27 Dec 2010 00:00:00 +1300

My blog has been migrated successfully to my Linode, which meant moving from one httpd (Apache) to another (Nginx), transferring MySQL data, and rewriting the rewrites ;)

So far so good. I wasn’t expecting it to go smoothly at all. In celebration I’ve gone through my old posts and deleted or edited stuff that wasn’t really relevant or interesting. So hopefully the average post quality has increased a bit :)

Cheers for now! And a belated Merry Christmas and Happy New Year to everyone!

My Linode Experience

zane.a@demonastery.org (Zane Ashby) — Sun, 05 Dec 2010 00:00:00 +1300

As mentioned in a previous post, I have been using a Linode for the past few months and I just want to say that the experience I’ve had has been perfect. I purchased a Linode 512 and I’m using it to host a few small websites on a pretty generic Nginx + PHP5.3 FastCGI stack, along with MySQL and Exim (as a send only MTA), and the whole setup sits comfortably in 50mb of memory and seems to perform well too (time will tell, I haven’t done any benchmarks). No special configuration has been needed other than setting up a basic directory layout for my BDSM project, which takes care of pushing my websites from my development box.

I would highly recommended Linode to anyone looking for a VPS, the support is amazingly quick, and the uptime is great; and if you use my referral link to sign up I can get some extra credits, so that would of course be much appreciated :)

HashTWM Musings

zane.a@demonastery.org (Zane Ashby) — Sun, 07 Nov 2010 00:00:00 +1300

I know there has been a lot of requests for features to be implemented or fixed in HashTWM. But the reality is, I’m barely using Windows anymore and so I don’t have an urgent need for HashTWM.

Despite all the progress around other tiling window managers for Windows I still believe there is room for improvement though, so I am putting some effort into getting a rewrite off the ground. My idea is to get a solid foundation built up that (if anything) through the power of open source, someone will be able to take and hopefully build their dream TWM out of.

So far the rewrite has the following implemented:

List structure (groups, with each group holding a list of windows, and a tiling method) and core list manipulation functions.
A keyhook that is used for all interaction, which supports key-chaining! (this was top priority for the rewrite. No more non-working keys!)
A small status window that can be used to display messages, or show the state of the keyhook input, with a look and feel similar to Ratpoison.
Window open/close/focus hooks all set up and mostly connected to the list functions.
A debug console that can be opened/closed on demand, for watching the window list and other internals.

Stuff that still needs to be done:

Integration of a scripting language. I will probably go with Lua since I am familiar with embedding it and I haven’t yet found a lisp that is tiny enough or easy to embed.
The ability to actually tile windows. I’ve decided that 100% of the window tiling code will be written in Lua, so being able to write your own tiling functions will be a top priority.
Other miscellaneous scripting hooks, because I want this to actually be useful.

So there you have it. I will be working on this a bit more on Monday, and I should have my current progress into a GitHub repository by Tuesday.

Cheers, Zane

Sawfish and Emacs/org-mode

zane.a@demonastery.org (Zane Ashby) — Wed, 27 Oct 2010 00:00:00 +1300

Hi there, today I’m going to write a small example on connecting the Sawfish window manager to the Emacs text editor.

Why might you want to do this? Well mostly I just wanted to further my usage of Emacs, and thought the idea of being able to clock in and out of tasks in org-mode whenever I change workspace or window would be pretty cool. Of course both Sawfish and Emacs make extensive use of the Lisp programming language) so it is a natural fit :)

To start off, you’ll want to be using the Sawfish window manager, and you’ll want to have emacs.jl somewhere in your lisp path. From there you can put something like the following in your ~/.sawfish/rc:

;; Require emacs.jl for emacs functions
(require 'emacs)

;; Define a hook to be run on workspace change, utilizes the emacs-eval function defined in emacs.jl
(define (my-enter-workspace-hook)
  (emacs-eval (format nil "(org-clock-in-on-workspace-change %S)" (nth current-workspace workspace-names))))

;; Add our hook!
(add-hook 'enter-workspace-hook my-enter-workspace-hook)

You will need to reload Sawfish for these changes to take effect (or you can eval them from Emacs).

Our hook makes Sawfish tell Emacs to run the org-clock-in-on-workspace-change function, passing the workspace name to it. We will define this now, open up your ~/.emacs and place this somewhere:

;; The function that Sawfish calls
(defun org-clock-in-on-workspace-change (workspace)
  (org-clock-out t) ; The t will silence the error that appears if no task is clocked
  (org-map-entries ; Loop over org headings
   'org-clock-in ; Clock in to this task ..
   workspace 'agenda)) ; .. if the tag has same name as current workspace
; Now press C-x C-e here to load this function into emacs

Now that this is done, we have what is needed for this to function, and in fact, if all has gone well, Sawfish should now be communicating and running this Emacs function each time you switch workspace!

Now, to make this useful, open up one of your agenda files, and add a tag to it, such as :Web: or :Emacs: etc. When that workspace is switched to in Sawfish, the task will be clocked in and out of automatically!

Hope you find this useful, I’m sure I will! :D

Edit: Changed to use workspace names instead of number. This can be coupled with the function below to quickly rename workspaces:

;; Bind this to a key like (rename-workspace current-workspace (prompt #:title "Workspace Name:"))
(define (rename-workspace n name)
  "Rename the Nth workspace to NAME"
  (setq workspace-names
        (let ((i -1))
          (mapcar #'(lambda (item)
                      (if (= n (setq i (1+ i)))
                          name
                        item)) workspace-names))))

Scheme-to-PHP

zane.a@demonastery.org (Zane Ashby) — Tue, 28 Sep 2010 00:00:00 +1300

I’m writing this post to inform of my latest GitHub repo, Scheme-to-PHP, which contains the beginnings of a very very naive Scheme to PHP5 translator. It will do so by implementing r4rs (or maybe r5rs) forms and macros in Scheme, that return the equivalent strings of PHP code, hopefully forming a working PHP script. There will be a way of calling native PHP functions and classes, and Scheme functions such as map will be mapped (no pun intended) to the equivalent PHP function (eg. array_map).

This is being written using Chicken Scheme, which I’m currently spending most of my time hacking about with and is totally awesome :)

XMMSinatra

zane.a@demonastery.org (Zane Ashby) — Fri, 10 Sep 2010 00:00:00 +1200

Last night I released the first version of XMMSinatra, a tiny and minimal XMMS2 web client written in Sinatra (Ruby). You can find the code and a screenshot at the Github repository.

Hackfest Weekend

zane.a@demonastery.org (Zane Ashby) — Wed, 01 Sep 2010 00:00:00 +1200

Back from a really fun hacking weekend in Wellington, where I met some new people (and fellow hackers) and got to work on a project integrating TBB further into the HipHop-PHP compiler (and exposing it to PHP), which can be found at Github. We made some pretty good progress and came up with a few pretty graphs.

As mentioned in the last post, I have decided to purchase a Linode VPS for a couple of months to try it out, and so far I am super impressed with the overall service. I will be using it mainly as a LNMP (Linux, Nginx, MySQL, PHP) host and so far it is doing the job well. I will also be spending the coming months looking further into RoR, Perl, a couple of NoSQL servers (CouchDB, Redis), and maybe a message passing framework or two. This will also give me a chance to play around with some monitoring systems, and some deployment systems, such as Capistrano.

As a side-note, anyone have any ideas of what to do with a bunch of Clickatell SMS credits? I have an account with plenty of credits but it’s sitting pretty stagnant at the moment.

Also really looking forward to visiting Christchurch in the coming weeks. Haven’t been there in forever.

ProtoIRC

zane.a@demonastery.org (Zane Ashby) — Fri, 09 Jul 2010 00:00:00 +1200

So I made a tiny and very hackable IRC bot/client base in PHP for rapid prototyping. Of course I threw it on GitHub. It makes heavy use of PHP >= 5.3 closure support as well as regular expressions for defining just about everything. Basic knowledge of the IRC protocol is recommended. You can find more information in the README file in the previous link.

Here is an example of what a minimal bot looks like:

<?php
require('protoirc.php');

$irc = new ProtoIRC('nick@hostname:6667', function ($irc) {
        // This code will run on connect
        $irc->send('JOIN #channel');
});

$irc->in('/^:(.*)!~.* PRIVMSG (.*) :!echo (.*)/', function ($irc, $nick, $channel, $args) {
        // Arguments are self documenting
        $irc->send($channel, "Echoing '{$args}' for you {$nick}", 'green');
});

// Also available is the ability to catch stdin, irc in, and irc out. Set up timers, and call functions asynchronously (fork/join).

$irc->go();

HashTWM Patch

zane.a@demonastery.org (Zane Ashby) — Wed, 23 Jun 2010 00:00:00 +1200

This morning I woke up to find a patch waiting for me on GitHub that extends HashTWM’s primitive tag support with what appears to be a more full featured, dwm-like tag support. Thanks to http://github.com/gtellalov for this patch :)

This is the beauty of open source :D

LibOrgParser Update

zane.a@demonastery.org (Zane Ashby) — Thu, 03 Jun 2010 00:00:00 +1200

Today I brought my LibOrgParser repository up to date with my local copy, for the first time in a while since I’ve been rather slack with my local repository.. but hopefully I got everything. The new version brings reading and writing functionality, as well as a new API, and the OrgQL utility, which lets you run simple SQL like queries on an org-mode file, thanks to the SQLite library. Queries that look like this,

SELECT ALL FROM /home/hashbox/todo.org WHERE heading CONTAINS todo

Oh and I found this image I made a while ago, kinda neat I think :)

Add OrgQL to that, and that’s pretty much my todo list flow :)

Edit: Oh and while we’re at it, here’s a one liner bash function for opening links in a file:

function nav() { grep -ohE "[[:alpha:]]*://[[:alnum:][:punct:]]*" $@ | while read; do xdg-open "$REPLY"; done; }

# use like this
nav todo.org someotherfile.txt

Misc Win32 Utilities

zane.a@demonastery.org (Zane Ashby) — Tue, 01 Jun 2010 00:00:00 +1200

Just created a new git repository on GitHub for my Miscellaneous Win32 utilities. Right now it just has my ExplorerGestures code, but I will be adding some more utilities as I find them on my hard drive.

Edit: Added some more utilities. Probably still more to come..

PrepFS

zane.a@demonastery.org (Zane Ashby) — Mon, 31 May 2010 00:00:00 +1200

Been a while since I posted anything here, and it’s always good to have some fresh content, so I thought I’d post my latest creation PrepFS (Pre-process FS), a small utility FUSE filesystem, that enables preprocessing of files.

My main motivation behind creating this, is enabling modified .Xdefaults dependent on running window manager, or machine it is being viewed from. An Example of usage would be something like this:

~/.xinitrc

wm=`echo -e "openbox\nxmonad" | dmenu`
prepfs ~/.dotfiles/prepfs -b ~/.dotfiles/real -pp "gpp -D$wm -x \"%s\""
exec $wm

~/.dotfiles/real/.Xdefaults

#ifdef openbox
	blah*blah: blah
#else
	this*stuff: here
#endif

Then make sure ~/.Xdefaults is symlinked to ~/.dotfiles/prepfs/.Xdefaults

More information (including source) can be found here http://bbs.archlinux.org/viewtopic.php?pid=576680

MPD Class for PHP

zane.a@demonastery.org (Zane Ashby) — Mon, 31 May 2010 00:00:00 +1200

I’ve just been going through a couple of folders and I found a very basic PHP class I wrote to control the Music Player Daemon. Assuming the text protocol hasn’t changed much it should still work fine :)

<?php
/*
 * Base MPDControl Class
 * Provide functions for connecting and retrieving raw data from MPD
 */
class MPDControl {
	var $hostname, $port, $timeout, $socket, $errno, $errstr;
	function MPDControl($hostname = 'localhost', $port = '6600', $timeout = 3) {
		$this->hostname = $hostname;
		$this->port = $port;
		$this->timeout = $timeout;
	}

	function connect() {
		$this->socket = @fsockopen($this->hostname, $this->port, $this->errno, $this->errstr, $this->timeout);
		if (!$this->socket) {
			return false;
		} else {
			$this->getData();
			return true;
		}
	}

	function disconnect() {
		$this->sendRaw('close');
		fclose($this->socket);
	}

	function getData() {
		$lines = Array();
		$line = '';
		while ((substr($line, 0, 2) != 'OK') && (substr($line, 0, 3) != 'ACK')) {
			$line = fgets($this->socket, 256);
			$lines[] = $line;
		}
		unset($lines[count($lines)-1]);
		return $lines;
	}

	function sendRaw($string) {
		fwrite($this->socket, $string."\n");
	}
}

This is then complimented with a class that extends MPDControl.

<?php
/*
 * Extended version of MPDControl
 * Provides function for getting commonly used info
 */
class ExtendedMPDControl extends MPDControl {
	function getNowPlaying() {
		$this->sendRaw('currentsong');
		$song = $this->getData();
		foreach ($song as $line) {
			$line = explode(':', $line);
			switch ($line[0]) {
			case 'Artist':
				$artist = trim($line[1]);
				break;
			case 'Title':
				$title = trim($line[1]);
				break;
			}
		}
		return Array((empty($artist) ? 'None' : $artist), (empty($title) ? 'None' : $title));
	}

	function randomOn() {
		$this->sendRaw('random 1');
		$this->getData();
	}

	function randomOff() {
		$this->sendRaw('random 0');
		$this->getData();
	}

	function play($id = '') {
		$this->sendRaw('play '.$id);
		$this->getData();
	}

	function stop() {
		$this->sendRaw('stop');
		$this->getData();
	}

	function clear() {
		$this->sendRaw('clear');
		$this->getData();
	}

	function remove($id) {
		$this->sendRaw('delete '.$id);
		$this->getData();
	}

	function add($path) {
		$this->sendRaw('add "'.$path.'"');
		$this->getData();
	}

	function getPlaylist() {
		$this->sendRaw('playlistinfo');
		$buffer = $this->getData();
		$playpos = -1;
		$artist = $album = $title = '';
		$playlist = Array();
		foreach ($buffer as $line) {
			$line = explode(':', $line);
			switch ($line[0]) {
				case 'Artist':
					$artist = trim($line[1]);
					break;
				case 'Album':
					$album = trim($line[1]);
					break;
				case 'Title':
					$title = trim($line[1]);
					break;
				case 'Pos': // End of song output
					$playlist[$playpos+1] = Array($artist, $album, $title);
					$playpos = trim($line[1]);
					$artist = $album = $title = '';
					break;
			}
		}
		return $playlist;
	}
}
?>

Consider this code to be in the public domain, so have fun with it!

ExplorerGestures

zane.a@demonastery.org (Zane Ashby) — Sat, 03 Oct 2009 00:00:00 +1300

So it’s 2:56 in the AM and I’ve just hacked up a little app to enable moving up a directory in Windows Explorer by using the Thunar middle click + drag up gesture. You can find it on my Github.

Enjoy.

Edit: This morning I’ve extended it to have left and right gestures to go backward and forward respectively just like Thunar and Nautilus. Down is used for exit rather than refresh as Windows seems to take care of this.

Automatic agenda notification

zane.a@demonastery.org (Zane Ashby) — Sat, 02 May 2009 00:00:00 +1200

This article will show you how to utilize Emacs org-mode, python, a Nokia mobile (others may work too), and an SMS gateway like Clickatell, in order to receive a daily agenda that fits nicely into the phones calendar by using the vCalendar format. Yes that’s a fairly specialized combination, but hopefully will be useful to someone. I’m sure it’s possible to do the same using bluetooth instead of and SMS gateway, and I may update this to reflect that at some stage..

Firstly, you will need org-mode set up and being utilized. Hopefully within it you will have something like:

* Write some code <2009-05-02 Saturday 3:00PM>
* Write some more code <2009-05-02 Saturday 8:00PM>

The idea is simple, we want some way of taking these headings, and turning them into vCalendar strings that can be sent to your phone.

This first script is what I use to do just that:

agenda.py

#!/usr/bin/env python
from subprocess import Popen,PIPE;
from time import strftime, strptime;
from sendsms import sendsms;

dateformat = "%Y%m%dT%H%M%S";

vcals = [];

output = Popen("/usr/bin/emacs -batch -eval '(org-batch-agenda-csv \"a\" org-agenda-ndays 1 org-agenda-show-all-dates t org-agenda-files `(,(expand-file-name \"/full/path/to/your/org/file\")))' 2>/dev/null", shell=True, stdout=PIPE).communicate()[0].strip();

for line in output.splitlines():
	[category, head, type, todo, tags, date, time, extra, priorityl, priorityn, date2] = line.split(",");
	if type and time:
		if type == "scheduled":
			head = "SCHEDULED, " + head;
		if type == "deadline":
			head = "DEADLINE, " + head;
		timestamp = strptime(date + " " + time, "%Y-%m-%d %H%M");
		vcals.append("BEGIN:VCALENDAR\nVERSION:1.0\nBEGIN:VEVENT\nCATEGORIES:APPOINTMENT\nDTSTART:" + strftime(dateformat, timestamp) + "\nDTEND:" + strftime(dateformat, timestamp) + "\nSUMMARY:" + head + "\nDESCRIPTION:" + head + "\nEND:VEVENT\nEND:VCALENDAR");

for vcal in vcals:
	sendsms(vcal, "yourphonenumberhere", "SMS_NOKIA_VCAL");

And here is the helper script to send sms through the Clickatell gateway:

sendsms.py

#!/usr/bin/env python
# Script to send SMS via clickatell

import urllib, urllib2;

username = "put your Clickatell username here";
password = "put your Clickatell password here";

api_id = "put your Clickatell api id here";

def sendsms(data, number = "yournumberhere", type = "SMS_TEXT"):
	request = "https://api.clickatell.com/http/sendmsg?user=" + username + "&password=" + password + "&api_id=" + api_id + "&to=" + number + "&msg_type=" + type + "&text=" + urllib.quote_plus(data);
	f = urllib2.urlopen(request);
	print f.read();

As long as this is in the same directory as agenda.py then it should import fine, otherwise you will want to move it into your Python PATH.

Now all you need to do is add something like this to your crontab (use crontab -e):

15 7 * * * /path/to/agenda.py

Make sure to replace everything in the scripts where necessary.

Congratulations! Your PC should be ready to send your daily appointments to your phone at 7:15 every morning :)

I can haz assembly!

zane.a@demonastery.org (Zane Ashby) — Mon, 20 Apr 2009 00:00:00 +1200

Simple CPUID, I also experimented with a version using an extra buffer variable and printf. It may not be much to others but I’m learning!

; CPUID

section .data
	buffer: 		db 	"CPU Vendor ID: XXXXXXXXXXXX", 10, 0
	bufferlen: 		equ 	$ - buffer

section .text
	global _start

_start:
	mov 	eax, 0 			; "Get maximum supported standard level and vendor ID string"
	CPUID 				; Call CPUID
	mov 	[buffer+15], ebx 		; Move 4 bytes from ebx to buffer+15
	mov 	[buffer+19], edx 		; Move 4 bytes from edx to buffer+19
	mov 	[buffer+23], ecx 		; Move 4 bytes from ecx to buffer+23

	mov 	eax, 4 			; write syscall
	mov 	ebx, 1 			; stdout
	mov 	ecx, buffer 			; buffer
	mov 	edx, bufferlen 		; size of buffer
	int 	80h 				; call kernel

_exit:
	mov 	eax, 1 			; exit syscall
	mov 	ebx, 0 			; Return 0
	int 	80h 				; call kernel

A simple wallpaper wrapper

zane.a@demonastery.org (Zane Ashby) — Fri, 13 Mar 2009 00:00:00 +1300

Edit as necessary, requires hsetroot, mplayer, and a working xvidix on your graphics card (for video).

#!/bin/sh
# Set Wallpaper

# If $1 is not empty
if [ -n "$1" ] ; then
	case "$1" in
	  last)
	  	# Grab last set wallpaper from file and store in $WALL
	   	WALL=`cat ~/desktop/lastwall`
		;;
	  *)
	   	# Set $WALL from command line and write to file for future use
	   	WALL=$1
		echo $1 > ~/desktop/lastwall
		;;
	esac

	case "$WALL" in
		*.jpg|*.jpeg|*.png|*.gif|*.bmp)
			# $WALL is an image file, so use hsetroot to set it as the background
			echo Setting with hsetroot...
			hsetroot -full "$WALL"
			;;
		*)
			# $WALL is likely not an image, so attempt to play with mplayer
			echo Setting with mplayer...
			# Blank out background first
			hsetroot -solid "#000000"
			# "Play" background using colorkey
			sudo mplayer -fs -vo xvidix -rootwin -colorkey 000000 -quiet "$WALL" &
			;;
	esac

	# Return good
	exit 0
else
	echo Please specify an image or a video file to set, or use "last"

	# Return bad
	exit 1
fi

To use, run setwallpaper.sh /path/to/image/or/video/file or setwallpaper.sh last

Change fonts dynamically

zane.a@demonastery.org (Zane Ashby) — Wed, 18 Feb 2009 00:00:00 +1300

After some Q and A on the ArchLinux forums, I am left with this in my .zshrc, the ability to change fonts on the fly:

vim_font() {
	echo -e '\e]710;xft:Terminus:style=Regular\007'
	vim $*
	echo -e '\e]710;xft:lime:style=Regular\007'
}
alias vim='vim_font'