I do robots

Google Reader alternative for Emacs Ninjas

Kajtek — Sat, 30 Mar 2013 22:37:00 +0000

With Google Reader being discontinued and everyone looking for alternatives I’ve decided to look for a little less “standard” solution, and hey, it turns out Emacs can be a pretty powerful RSS reader.

Newsticker.el

News Ticker is a built-in Emacs feed reader that doesn’t get much attention for some reason. It is feature-rich, handles both RSS 2.0 and Atom feeds and has quite a bunch of tweakable options.
Here’s a simple setup to start with:

(require 'newsticker)

; W3M HTML renderer isn't essential, but it's pretty useful.
(require 'w3m)
(setq newsticker-html-renderer 'w3m-region)

; We want our feeds pulled every 10 minutes.
(setq newsticker-retrieval-interval 600)

; Setup the feeds. We'll have a look at these in just a second.
(setq newsticker-url-list-defaults nil)
(setq newsticker-url-list '("..."))

; Optionally bind a shortcut for your new RSS reader.
(global-set-key (kbd "C-c r") 'newsticker-treeview)

; Don't forget to start it!
(newsticker-start)

Migration

First of all, you have to export your Google Reader data; you can do this here by following these instructions. Download and unzip it into a safe location.
Now, all you will need to migrate from Google Reader to News Ticker is this little piece of code:

(require 'xml)

(defun assoc-or-error (what where &optional err-string)
  (or (assoc what where)
      (error (or err-string
                 "Suddenly errors! Thousands of them!"))))

(defun google-reader-to-newsticker (filename)
  "Parses your google-reader feed subscription XML
 and returns newsticker compatible feed alist."
  (with-temp-buffer
    (insert-file-contents filename)
    (let* ((opml (assoc-or-error
                  'opml
                  (xml-parse-region (point-min)
                                    (point-max))
                  "Not a valid feed XML!"))
           (body (assoc-or-error
                  'body
                  opml
                  "Not a valid feed XML!"))
           (outlines (delq nil
                           (map 'list
                                (lambda (element)
                                  (and (consp element)
                                       (equal (car element)
                                              'outline)
                                       element))
                                body)))
           (alist
            (map 'list
                 (lambda (outline)
                   (let ((title (assoc-or-error
                                 'title
                                 outline
                                 (concat "No title in an outline "
                                         "- malformed feed XML?"))
                         (feed (assoc-or-error
                                'xmlUrl
                                outline
                                (concat "No feed link in an outline "
                                        '"- check your feed XML!")))
                     (list (cdr title) (cdr feed))))
                 (map 'list
                      #'cadr
                      outlines))))
      alist)))

Simply eval it in your Emacs and run the following lines to import all your Google Reader feeds directly to News Ticker.

(setq newsticker-url-list
  (google-reader-to-newsticker "/path/to/subscriptions.xml"))

You might want to save your feeds for later via Newsticker Url List setting under:

M-x customize-group newsticker-retrieval

As with anything Emacs, you can bend News Ticker to your will and make it do whatever you please. Depending on your Emacs theme it might look something like this:

Go ahead, customize all the things!

Extra ninja

If you, like me, read loads of feeds every day you might consider adding a tiny notification thing-a-ma-jigger to your Emacs mode-line, just place the following code in your custom mode-line-format…

(setq-default mode-line-format
  (list
    ; ...

    '(:eval (let ((unread (or (newsticker--stat-num-items-total 'new)
                              0)))
              (when (> unread 0)
                (propertize
                  ; Any text will do, be creative!
                  (format "RSS: %d" unread)
                  'face 'some-colorful-font-face
                  'help-echo (format "You have %d unread RSS items!"
                                     unread)
                  'mouse-face 'mode-line-highlight))))))

…and enjoy it popping into existence every now and then (note the use of awesome Font Awesome):

Happy procrastinating!

MMO Life

Kajtek — Sat, 02 Feb 2013 22:59:00 +0000

This is a follow-up post to Gamification showing how I use it and what purpose does it serve me.

In summary, I’m a kind of control freak who likes all sorts of stats (such as my systems stats or a projects repo stats) displayed neatly all over the place, and it was only a matter of time before I started monitoring myself, and so I wrote a tiny tool, Gamify, that integrates with Emacs’ Org-Mode and tracks my skills, their dependencies and their development.

Endless adventure

Gamify collects experience points associated with Org-Mode tasks whenever I complete them. Each task can be tagged with any number of skills (Org’s tag inheritance is very handy here) and assigned some XP, preferably using gamify-assign-some-exp:

* TODO Write a follow-up post about Gamify.                 :Blogging:
SCHEDULED: <2013-02-02 sat>
:PROPERTIES:
:gamify_exp: 20
:END:

When I complete this task by changing its state to *DONE*
Gamify will take care of updating my /Blogging/ skill.

As every Gamify-enabled task is assigned an arbitrary XP some calibration of skill-levels was needed. I’ve settled for a slightly modified version of DF level names (because I’m nerdy like that) and an exponential effort growth:

It takes roughly 4 years of daily skill training (6 tasks 12 XP each on average) to get a hold at a skill and become Professional, 20 years to become a Legendary hacker and 63 years to become Tesla.

Naturally, to be any useful Gamify has to provide lot’s of feedback which it does either in textual form using gamify-get-pretty-stats:

Your Gamify stats:
Competent at Blogging: 3836/8500 (2%)
Competent at C++: 8144/8500 (92%)
Proficient at CodeDev: 23805/28900 (58%)
Competent at Concurrency: 4129/8500 (8%)
Competent at D: 5522/8500 (37%)
Competent at Editing: 5283/8500 (32%)
Competent at Emacs: 4994/8500 (26%)
Skilled at Functional Programming: 8829/16600 (4%)
Competent at GameDev: 6104/8500 (50%)
Skilled at Imperative Programming: 16092/16600 (93%)
Competent at Lisp: 5523/8500 (37%)
Skilled at OOP: 9323/16600 (10%)
Competent at Project Management: 3963/8500 (5%)
Proficient at Programming: 19490/28900 (23%)
Competent at Robotics: 6884/8500 (66%)
Competent at Software Engineering: 3700/8500 (0%)

…or using Graphviz for graph visualization.

Some more examples

In a nutshell, this is me:

Well, to be honest most of the skills I’m novice or dabbling at don’t belong in my defining skill-set, so more like this is me:

…and this is what I’m good at:

Additionally, Gamify monitors my interests…

…and how they interact with each other:

But most importantly, it helps me estimate whether I’m qualified for a particular task or not.
Say, you want me to build an Operating System in D. All I need to do is filter my skill-set by D and OSDev, yielding a bunch of relevant info:

I mean I did write a toy kernel in D that does absolutely nothing, so… Yeah…

Anyway, say, you want me to help develop an OS… In Lisp… For your robots:

I may not be particularly well-suited for this job right away, but I immediately see lot’s of room for self-improvement. I could, for example, take an ML course or two and start a toy robotics project for fun and profit, and who knows, maybe in five years I’ll fit just right.

ASM development log 4: Tiny MOP

Kajtek — Sat, 19 Jan 2013 17:00:00 +0000

Finals are comming, so I might as well hack around a bit with ASM…

It’s been a while since the last status update and I hate to admit it, but not much has changed in ASM repo. I was messing around with combinators in an attempt to simplify ASM’ environments, and I was experimenting with new immutability semantics, since at the moment it’s pretty much a one big copy-vs-alias mess. There are still a bunch of unresolved issues here and there concerning efficiency mainly, but if ASM is to be relevant in 100 years of time I’d much rather sacrifice efficiency for simpler semantics and expressive power.
Lastly, I was thinking about a way of exposing as much of ASM’ semantics as possible and allowing their run-time overriding, using a Metaobject protocol:

(import 'samples.tinyclos)

(defmethod apply ((v Vector) n)
  (write "Applying a vector to something? Are you " n "?"))

(apply '[1 2 3 4] '(nuts))

TinyCLOS

TinyCLOS is an object system that includes a metaobject protocol developed by Gregor Kiczales at Xerox for the Scheme programming language. It’s relatively simple yet immensely powerful and porting it to ASM was both great fun and a nice test for the capabilities of the language. Running rather slowly as ASM’s testing interpreter is very cons-and-copy-happy it continues to amuse me even with its basic features such as generic methods with multiple dispatch:

(import 'samples.tinyclos)

(defclass Point (Object)
  'x 'y)

(defmethod initialize ((p Point) initargs)
  (call-next-method)
  (initialize-slots p initargs))

(defclass Point3D (Point)
  'z)

(defvar p1 (new Point 'x 1 'y 2))
(defvar p2 (new Point 'x 2 'y 3))
(defvar p3 (new Point3D 'x 5 'y 5 'z 5))

(defgeneric distance)
(defmethod distance ((a Point) (b Point))
  (write "Point * Point\n")
  (distance (new Point3D 'x (a 'x) 'y (a 'y) 'z 0)
            (new Point3D 'x (b 'x) 'y (b 'y) 'z 0)))

(defmethod distance ((a Point) (b Point3D))
  (write "Point * Point3D\n")
  (distance b a))

(defmethod distance ((a Point3D) (b Point))
  (write "Point3D * Point\n")
  (distance a (new Point3D 'x (b 'x) 'y (b 'y) 'z 0)))

(defmethod distance ((a Point3D) (b Point3D))
  (write "Point3D * Point3D\n")
  (defvar dx (- (b 'x) (a 'x)))
  (defvar dy (- (b 'y) (a 'y)))
  (defvar dz (- (b 'z) (a 'z)))
  (pow (+ (* dx dx) (* dy dy) (* dz dz) 0.5)))

(distance p1 p2)
(distance p3 p1)
(distance p2 p3)
(distance p3 p3)

Output:

Point * Point
Point3D * Point3D
Point3D * Point
Point3D * Point3D
Point * Point3D
Point3D * Point
Point3D * Point3D
Point3D * Point3D

F(ea|u)ture?

I once were an OOP enthusiast, but grew to hate it for various reasons. Most of all, I fell in love with functional programming and OOP (at least the Java-flavour) suddenly started looking clumsy and awkward. The world wasn’t made of objects anymore, it was made of foldr and foldl instead. Now, although I still don’t see ASM as an OOP-heavy language, I’m sure it’ll make some use of it – for example implementing ranges with all their benefits comes naturally in an OOP-enabled language.
Furthermore, to extend ASM’s expressiveness beyond what any other language has to offer I will need a meta-language protocol of sorts, perhaps Tiny MOP is a good start towards that…
Thing…

You earned 15 XP in Getting Things Done!

Kajtek — Fri, 07 Dec 2012 18:00:00 +0000

Gamification

According to the Oxford Dictionary…

Gamification (ˌɡeɪmɪfɪˈkeɪʃ(ə)n) is the application of typical elements of game playing (e.g. point scoring, competition with others, rules of play) to other areas of activity, typically as an online marketing technique to encourage engagement with a product or service:
gamification is exciting because it promises to make the hard stuff in life fun.

Let’s see how to apply it to optimize performing daily activities and get some useful statistics out of it…

Disregard contexts, acquire experience

I use Emacs Org-Mode, a plain text focused, organization powerhouse, to manage both my work and my private life implementing the Getting Things Done techniques. And as far as Org-Mode goes it works like a charm, but there’s still the human factor…

I hate to admit it, but I’m a slow-starter. Beginning some of the tasks, especially the seemingly harder ones, tends to be a problem for me and I usually need a considerable amount of preparation time beforehand, or an outside motivator of sorts, for example a milestone deadline or a course grade.

Staying focused on a performed task or keeping a task streak going has never been a real problem for me, and ever since I optimized it using the Pomodoro technique it became apparent that most of my productivity loss comes about before beginning a Next Action – it takes me quite some time and effort to actually start a series of actions that make up a complex task when I’m not looking forward to doing them and there’s no real sense of urgency or reward. I just keep pushing the task back and back.

To overcome this recurring phenomenon I took a closer look at my GTD workflow – task contexts in particular.
I used to tag my Org-Mode tasks based on the place they could be carried out and sometimes by their type, what looked something like this:

It turns out that such context tags are barely useful and carry little to none statistical value, and since I tend to keep all my working environments closely synchronized these contexts weren’t even valid half the time – the tasks could be performed in either context. This got me thinking and I decided to drop task contexts whatsoever in favour of something more useful…

Gamify.el

…and fun. This Emacs package is my attempt at doing so. It’ll help you keep track of your stats – any quantifiable values you name, be it your soft skills or your experience with various technologies and software. At its current state it’s mostly usable together with Org-Mode and GDT to increase your productivity and motivation in your daily routine.

To get started with Gamify simply add this to your .emacs:

(require 'gamify)
(gamify-start)

There are a few customizable variables to tweak (which you might want to check out here), but I’ll focus on the Org-Mode integration (enabled by setting gamify-org-p to t).

Whenever you complete an Org-Mode task by setting its state to DONE Gamify will try to interpret its tags and properties and update your stats accordingly. All you really need to do is assign some experience to your task, preferably automatically at capture-time:

(setq org-capture-templates
  (list* `("1" "New easy quest." entry (file "")
               ,(concat "* TODO %?\nSCHEDULED: %t\n"
                  ":PROPERTIES:\n"
                  ":gamify_exp: %(gamify-assign-some-exp 5 2)\n"
                  ":END:\n"
                  "%U\n%a\n %i\n"))
         `("2" "New medium quest." entry (file "")
               ,(concat "* TODO %?\nSCHEDULED: %t\n"
                  ":PROPERTIES:\n"
                  ":gamify_exp: %(gamify-assign-some-exp)\n"
                  ":END:\n"
                  "%U\n%a\n %i\n"))
         `("3" "New hard quest." entry (file "")
               ,(concat "* TODO %?\nSCHEDULED: %t\n"
                  ":PROPERTIES:\n"
                  ":gamify_exp: %(gamify-assign-some-exp 30 10)\n"
                  ":END:\n"
                  "%U\n%a\n %i\n"))
        org-capture-templates))

…and tag them by the stat they train or require:

New tagging scheme might seem time and display space consuming at first, but thanks to tag inheritance and stat aggregation provided by Gamify it quickly becomes a second nature. In fact, my getting things done workflow stayed unchanged – I still capture, tag, refile and perform my tasks as usual.

What changed, however, is the amount and type of information I’m gathering – instead of “just a task archive” I now have more data to play with, to enhance my productivity and motivation, to boldly go where no man has gone before!

It’s not gamification if there’s no XP bar!

Or well, you know, XP percentage indicator due to limited space of the Emacs mode-line:

This little fellow does wonders. This type of feedback is essentially the core concept behind gamification itself – seeing your progress helps you stay motivated to progress even further.

Gamify includes a Graphviz dot exporter to provide extra feedback – it builds a colorful graph of stats and their dependencies which shows how different stats depend on each other and how developed they are. The exporter supports filtering, so it is possible to focus on a specific part of the graph or filter out stats that are less important or less developed.

Following is an example subgraph of my skill-set. Skills that didn’t make it past filtering are barely visible on the graph not to obscure it:

There’s some useful information to be seen on this graph, for example programming languages I know or what my toolchain is. My Valgrind skill is marked red meaning that it went rusty because it wasn’t updated for a while. Perhaps that’s something I could focus on in the future? This type of data is invaluable when identifing your weak spots that require improving and it’s right there, awaiting interpretation.

With all these neat things on my side I’m not hesitant in starting new tasks anymore.

System monitor in Emacs mode-line

Kajtek — Wed, 10 Oct 2012 16:00:00 +0000

Resistance is futile…

As we all know Emacs is a great operating system and a decent editor, and as such it has been serving me really well – I find myself assimilating more and more of my tools and daily activities into the Emacs collective. Recently I realised that Conky just wouldn’t cut it anymore…

First of all, I barely look at my desktop. There’s just no reason to do that other than checking some of the system stats such as memory usage or CPU load when I’m hacking arround and testing stuff.

For this particular use-case I figured the Emacs mode-line would be perfect to display all the relevant statistics directly in Emacs in such a way that I could glance through them without interrupting my workflow – giving me real-time feedback with minimal distraction.

Package

The package I wrote contains a bunch of easy to use modules that provide various system stats directly in the Emacs mode-line:

cpu-stats.el – provides an easy way to display various CPU stats derived from /proc/stat. Usage:

(require 'cpu-stats)
(setq cpu-usage-update-interval 1)
(setq cpu-usage-format "Average: %A CPU0: %C0 CPU1: %C1")
(cpu-usage-start)

memory-stats.el – display many different RAM and SWAP statistics in the mode-line. Usage:

(require 'memory-stats)
(setq memory-usage-update-interval 5)
(setq memory-usage-format "Mem: %R Free: %F Swap: %S")
(memory-usage-start)

network-speed.el – displays network load in the mode-line. This one was written by Vicente Hernando Ara quite some time ago and cycles the net ever since. Usage:

(require 'network-speed)
(setq network-speed-update-interval 5)
(setq network-speed-precision 1)
(setq network-speed-interface-list '("wlan0" "eth0"))
(setq network-speed-format-string "Down: %RB Up: %TB")
(network-speed-start)

misc-stats.el – various system and Emacs stats such as load-averages, uptime etc. Usage:

(require 'misc-stats)
(setq misc-stats-update-interval 10)
(setq misc-stats-format "Emacs uptime: %E Load average: %L1")
(misc-stats-start)

Additionally, there are some system monitors already bundled with Emacs, such as battery.el, useful for laptop users.

Mode-line hacking

The package will look something like this out of the box:

(click me)

…but with enough elbow grease you can make it look like this:

(click me)

Let’s start with evaluating arbitrary code in the mode-line-format as it’s fairly simple.

You can use either (:eval ...) or (:propertize ...) in order to evaluate some code that returns a string or propertize it similarly to the propertize function:

(setq mode-line-format
  (list '(:eval (message "Using `message' here is a bad idea..."))
        '(:propertize " No really. Stop it!"
                      face font-lock-warning-face)
  ))

Propertizing mode-line strings gives us an opportunity to add colors to this boring part of the UI. For example in order to color the buffername according to the version control status of its associated file, we can add this to the mode-line-format:

(defvar my-vc-alist '(;; Everything is ok:
                      (up-to-date some-green-face)
                      ;; Kinda important:
                      (edited some-yellow-face)
                      (added some-yellow-face)
                      ;; Most important:
                      ;; ...
                     ))

(setq mode-line-format
  (list ;; ...
         '(:eval (let ((file-name (buffer-file-name)))
              (if file-name
                  (let ((state-face (assoc (vc-state file-name)
                                           my-vc-alist))
                        (revision (vc-working-revision file-name)))
                    (propertize (concat "%b"
                                        (when revision
                                          (concat " [" revision "]")))
                                'face (cadr state-face)))
                  "%b")))
        ;; ...
  ))

Custom tool tips are fine too:

(setq mode-line-format
  (list ;; ...
        '(:propertize "%@" help-echo (concat "Default directory is: "
                                             default-directory)
                           mouse-face mode-line-highlight)
        ;; ...
  ))

And a neat little thing – mode-line images. This one is a little trickier since Emacs has a hard time displaying .png‘s in the mode-line for some reason… I advise using .xpm‘s instead:

(defvar some-image (create-image "foo.xpm" 'xpm nil
                                 :ascent 'center))

(setq mode-line-format
  (list ;; ...
        '(:eval (propertize "unimportant" 'display some-image))
        ;; ...
  ))

Lastly, here you will find my lengthy, custom mode-line code*. Happy hacking.

* It does not use all the stuff the package has to offer to elliminate some redundancies.

ASM development log 3: DSLs

Kajtek — Fri, 17 Aug 2012 11:03:00 +0000

“Kajtek, you incredibly handsome stallion, what have you been doing these past few months?” – you might ask, concerned about the lack of ASM dev logs recently…

Well, I’ve mostly been studying various PL design quirks and prototyping neat features such as vau calculus flavoured fexprs or the following piece of what I consider art.

As mentioned before, I was working on an extensible reader that would support user-defined reader macros for easy DSL programming. It took me quite some time, effort and researching but eventually I came up with an awesome solution.
It’s worthy to mention here, that it’s in no way a new solution. I prefer to figure stuff out myself and often times it turns out that similar concept already existed a few years before mine. Bummer u_u.

PEG reader generator

The idea is simple – modify the syntax of the hosting language using full capabilities of said language extending its functionality on the fly. As simple as it may sound it’s not simple at all.

Most common parsing techniques such as using CFG and LL(k) or LR(k) parsers are not particularly well-suited for this task, because they require a separate phase of lexical analysis which, while sounding innocently, complicated the design of the reader sufficiently enough for me to drop the idea for several weeks. Long story short, I started looking for something different but equally powerful, such as hygienic macros or fexprs with further improvements, and eventually stumbled upon this.

PEG is a scannerless parsing technique designed as an alternative to CFG’s. PEG’s are expressive and packrat parsers generated for PEG’s work in guaranteed linear time thanks to memoization, but what’s most important – packrat parsers are dead simple to generate.

My second experimental (but most likely final) reader design is based on PEG parser generation – given a set of grammar rules and (optional) code transformations it generates immensely recursive (but not yet memoized) parser that can be easily extended with new rules thanks to (but not necessarily requiring) late binding.

Here’s an example, which you can try out yourself by importing experimental.parser2:

(grammar ((Expression < (/ String List Atom)))
         ((String     <- (:"\"") "[^\"]*" (: "\"")))
         ((List       < (: "\\(") (* Expression) (: "\\)"))
                        `($(car List)
                          $(cdr List)))
         ((Atom       <- (/ Number Symbol)))
         ((Number     <- "[+\\-]?[0-9]+(\\.[0-9]*)?")
                         `($(car Number)
                           ($(str->num (caadr Number)))))
         ((Symbol     <- (! Number) "[^\\(\\)\"';\\s]+")
                         `($(car Symbol)
                           ($(str->symbol (caadr Symbol)))))
         ((Spacing    <- (* (/ Comment "[\\s]+"))))
         ((Comment    <- (: ";" "[^\n]*\n"))))

(Expression "(define (compose f g)
               (lambda (arg) (f (g arg))))")

Few things to notice about this simple Lisp grammar definition:

It’s very succinct and it mostly resembles a formal grammar definition of Lisp.
It uses quasiquotation and other hosting language features to modify the parse tree. Seemingly clumsy, code transformations will be further improved once pattern matching is implemented in the language.
It uses regexps for convenience.
It doesn’t look anything like PEG’s – dropping operator precedence simplifies the generator greatly. It’s quite ironic, since this reader facility will most likely be used to introduce operator precedence and complex syntax rules to ASM DSLs. The correspondence of ASM reader syntax to PEG syntax is represented on the following snippet:

sequence:        (A B C ...)   => A B C ...
ordered choice:  (/ A B C ...) => A / B / C / ...
optional branch: (? ...)     => (...)?
zero or more:    (* ...)     => (...)*
one or more:     (+ ...)     => (...)+
not:             (! ...)     => !(...)
and (lookahead): (& ...)     => &(...)

drop node:       (: ...)     -  Drops a node from the parse tree.
concat captures: (~ ...)     -  Concatenates captures.

Grammar macros

As stated above, the reader is extensible and defining new grammar rules is very straightforward:

(syntax (Lambda < List (: "->") Expression)
  `($(car Lambda)
    ((lambda $(caadr Lambda) $(cadadr Lambda)))))

(syntax (Expression < (/ Lambda String List Atom)))

(Expression "(map (x) -> (* x x)
                  (list 1 2 3 4 5))")

It also explicitly states the interaction of a new macro with the rest of the grammar making it safe to use and easy to debug.

Here’s another example, that extends ASM grammar to support direct manipulation of JSON objects:

(grammar ((JValue  < (/ String Number JObject
                        JArray JTrue JFalse JNull)))
         ((JObject < (: "\\{") (? JPair (* (:",") JPair)) (:"\\}"))
           `($(car JObject)
             ($(cons 'scope (cadr JObject)))))
         ((JPair   < String (: ":") JValue)
           `($(car JPair)
             ((var $(str->symbol (caadr JPair)) $(cadadr JPair)))))
         ((JArray  < (:"\\[") (? JValue (* (:",") JValue)) (:"\\]"))
           `($(car JArray)
             ($(vectorof (cadr JArray)))))
         ((JTrue   <- (: "true"))
           `($(car JTrue)
             ('t)))
         ((JFalse  <- (: "false")))
         ((JNull   <- (: "null"))))

(syntax (Expression < (/ Quote JObject String List Atom)))

And after running the experimental REPL by invoking (repl) you can use it like this:

(var json { "number": 1234.567,
            "string": "abcd",
            "object": { "member0": "value",
                        "member1": "value" },
            "boolean": true,
            "null": null })

(set! (json number) 9876.543)

Neat, isn’t it?

Reader, writer… Compiler?

There’s much space for improvement in the design and at the moment I’m trying to come up with a simple and natural way to sew ASM writer (facility responsible for printing ASM code) together with the reader. Ideally defining one grammar will be enough to generate both the reader and a complimentary writer, however custom writers will be possible facilitating language-to-language translation.
For example, ASM’ bytecode compiler might be implemented in terms of such a writer. Ahhh, the delicious symmetry.

Most likely pattern matching and some form of sealer/unsealer pattern will be used to achieve this.

I’ve recently started using Org2Blog to manage this blog and it turned out to be such an awesome tool that I feel obliged to mention it here. So there’s that.

There is nothing cooler than a macr- Err… Mixin?

Kajtek — Fri, 20 Jul 2012 19:01:00 +0000

One of the most distinctive features of Common Lisp and Lisp in general, are its code-generation and code-manipulation capabilities.

Probably the best example is the LOOP macro – a Swiss Army knife of iteration that can do pretty much anything. The following snippet iterates a list of random numbers collecting some statistics of its contents and does that while being very concise and readable:

(let ((random (loop with max = 500
                    for i from 0 to max
                    collect (random max))))
  (loop for i in random
          counting (evenp i) into evens
          counting (oddp i) into odds
          summing i into total
          maximizing i into max
          minimizing i into min
        finally (format t "Stats: ~A"
                          (list min max total evens odds))))

Stats: (0 499 120808 261 240)

Here‘s my version written in the D programming language.
It uses CTFE to transform LOOP definitions and generate D code at compile time while mixing it together with the rest of the code extending the language with a DSL of similar capabilities:

auto random = mixin(Loope!q{
    with max = 500
    for i from 0 to max
      collect $$ uniform(0, max) $$
});

mixin(Loop!q{
    for i in random
      counting $$ (i&1) == 0 $$ into evens
      counting $$ (i&1) == 1 $$ into odds
      summing i into total
      maximizing i into max
      minimizing i into min
    finally $$ writeln("Stats: ", [min, max, total, evens, odds]) $$
});

Stats: [2, 499, 126399, 229, 271]

To compile this, D’s compiler first parses LOOP definitions passed to the Loop template using a parser generated (optionally at compile-time ;)) by Philippe Sigaud’s Pegged parser generator.
After that it traverses the parse tree translating it into valid D code, resulting in this, full of type-inference and meaningless identifiers, monstrosity:

auto random = (() {
    auto max = 500;
    auto __i_0 = max;
    auto i = 0;
    typeof(uniform(0, max))[] __accumulator;

    for(;;) {
        if(i >= __i_0) break;

        __accumulator ~= uniform(0, max);

        i += 1;
    }
    return __accumulator;
})();

{
    auto __i_0 = 0;
    auto __i_1 = random;
    auto __i_2 = __i_1.length;
    typeof(__i_1.init[0]) i;
    uint evens = 0;
    uint odds = 0;
    typeof(i) total;
    bool __max_3 = false;
    typeof(i) max;
    bool __min_4 = false;
    typeof(i) min;

    for(;;) {
        if(__i_0 >= __i_2) break;
        i = __i_1[__i_0];

        if((i&1) == 0) ++evens;
        if((i&1) == 1) ++odds;
        total += i;
        if(!__max_3 || i > max) {
            max = i;
            __max_3 = true;
        }
        if(!__min_4 || i < min) {
            min = i;
            __min_4 = true;
        }

        ++__i_0;
    }
    writeln("Stats: ", [min, max, total, evens, odds]);
}

That’s more than three times the volume of the previous snippet and it’s not nearly as readable. Imagine writing it yourself each time. The real fun, however, starts with complex loops:

auto random = randomStuff();  // Implemented elswhere. ;)

auto result = mixin(Loope!q{
    initially $$ writeln("Loop test:"); $$

    with isEven = $$ (uint x) => ((x&1) == 0) $$
    with updateAnalysis = $$ // A D function analysing our data.
                             (uint[] stats) {
                               static count = 0;
                               if(count++ % 10 == 0)
                                   writeln("Analysis: ", stats);
                             } $$

    with max = 500
    with data = $$ // Yo dawg...
                  mixin(Loope!q{
                      for i from 0.0 to max by 1.337
                        collect i
                  }); $$

    for i from 0 to max
    for datum in data
    for r in $$ sort(random) $$

      if $$ isEven(i) $$
        minimize i into minEven and
        maximize i into maxEven and
        unless $$ i % 4 == 0 $$
          sum i into evenNotFoursTotal and
          collect datum into floats
        end
        and sum i into evenTotal
      else
        minimize i into minOdd and
        maximize i into maxOdd and
        when $$ i % 5 == 0 $$
          sum i into fivesTotal and
          collect r into randoms
        end
        and sum i into oddTotal

      do $$ updateAnalysis([minEven, maxEven, minOdd,
                            maxOdd, evenTotal, oddTotal,
                            evenNotFoursTotal]) $$

      finally $$ writeln("Floats: ", floats); $$
      finally $$ writeln("Randoms: ", randoms); $$

      finally $$ return [minEven, maxEven, minOdd,
                         maxOdd, evenTotal, oddTotal,
                         evenNotFoursTotal]; $$
});
writeln("Result: ", result);

Just as the Lisp’ LOOP macro (not as elegantly, though) it blends together really well with the host language allowing for arbitrary D code to be used inside of the loop (including Loop template itself).

The code generator, however, is very different to any Common Lisp LOOP implementation. D being a statically typed language with complex, unlike Lisp, syntax lacks symbol manipulation and quasiquote, meaning it has to rely on string processing, CTFE and string mixins that, despite being highly experimental and prone to performance issues, are still very powerful.

Also… There is a macro keyword reserved for future use in the language.

Fingers crossed for this one. ;)

The title refers to this video.

What motivates me?

Kajtek — Fri, 08 Jun 2012 10:15:00 +0000

A quick post, despite being all busy and stuff, that answers a few questions for the Greater Good.

What motivates you to complete a Udacity course?

Most importantly the knowledge that is easily accessible.
It’s really attractive for me to take a course on a topic of my interest especially when it saves me the time I would otherwise spend on digging through the web researching stuff.
Secondly, initiatives such as Udacity (and the like) attract communities of people with whom I can share my thoughts and resolve any encountered problems. That’s the only kind of social interaction I, being an introverted CS student, accept. ;)

How useful are deadlines?

Very useful.
I’m the weird kind of person that needs his deadlines listed somewhere in order to get stuff done. It keeps me motivated and sets a certain priority for a task, the higher the closer its deadline is. When there’s no deadline it’ll just sink among all the other daily activities and eventually end up as “CANCELLED” in my Org-Mode archive. Now, scheduling deadlines on my own and keeping them is a lot harder than keeping a fixed, preset deadline. For some reason my own deadlines don’t seem important enough.

If you have not completed a course, what kept you from finishing it?

Currently I’m taking the Compilers course from Coursera (hope you guys don’t mind me mentioning your competitors ;)) but I had to cease doing the homework assignments solely because they took too much time to complete.

Compilers course lacks the neat balance that Udacity managed to maintain so far (judging on CS373 and AI-Class); the homework assignments aren’t hard but they consume a lot of time. Contrary, CS373 homework asignments were neither too hard nor too simple, meaning they were fun to complete, and most importantly they took adequate amounts of time.

What do you think Udacity could do to motivate you to complete a course?

Two things for sure – keep the courses as entertaining, interesting and well-prepared and keep the neat balance I’ve mentioned earlier. I have yet to try a programming competition (such as the one held for CS101 students) but I suppose a little competition always is a nice touch.

I do robots Beamer theme

Kajtek — Sat, 05 May 2012 00:04:00 +0000

Recently I’ve been looking for a simple and readable Beamer theme but all of the ones I found lacked something in one way or another. Finally, I settled for a theme of my own – based on Amsterdam theme by Rogier Koppejan adding frame numbering to the footer. It’s simple, it’s sleek. It’s all I want.

Here you can find a few sample slides using the theme and here you’ll find the theme itself.

It consists of a header containing outline of the presentation and a footer containing navigation box and all the necessary info such as authors name and institute, presentation title and a frame counter.

Templated Monads? Monadic Templates?

Kajtek — Sun, 15 Apr 2012 16:57:00 +0000

So, I finally found some time for a Template Metaranting follow-up post. This time let’s get down to business as this one contains a fair amount of code.

Sadly, I won’t rant as much but instead I’ll try to show how awesome D‘s templates really are. We’ll write a piece of code, based on this Scheme implementation, that is, a simple monad that we’ll use to build a binary tree, with uniquely numbered nodes containing their height, without any global state (therefore purely) entirely at compile time.

Quick Reader, grab my code!
ADVENTURE!

Let’s jump straight in, shall we?

import std.typecons;

template MakeNumberedValue(alias tag, alias val) {
  enum MakeNumberedValue = tuple(tag, val);
}

template NumberedValue(alias tv) {
  enum NumberedValue = tv[ 1];
}

template NumberedTag(alias tv) {
  enum NumberedTag = tv[ 0];
}

template Return(alias value) {
  template Return(alias counter) {
    alias MakeNumberedValue!(counter, value) Return;
  }
}

template Bind(alias M, alias F) {
  template Bind(alias counter) {
    enum t = NumberedTag!(M!counter);
    enum v = NumberedValue!(M!counter);
    alias F!v M1;

    alias M1!t Bind;
  }
}

So… That’s all. That’s the monad.
We define several simple templates that manage our numbered pairs. A pair consists of a unique tag and a value it stores.
Next we define two basic monad operations – that is – bind (>>=) and return (well… return).
I’ll leave checking the Monad Laws to the Reader as I’m too lazy to do it myself .

Let’s now build the binary tree analogically to the original Scheme implementation:

template Increment(alias n) {
  enum Increment = MakeNumberedValue!(n+1, n);
}

template MakeNode(alias value, alias kids) {
  template __Lambda(alias counter) {
    alias Return!(tuple(MakeNumberedValue!(counter, value), kids))
          __Lambda;
  }

  alias Bind!(Increment, __Lambda) MakeNode;
}

template BuildBtree(alias depth) {
  static if(depth == 0) {
    alias MakeNode!(depth, "leaf") BuildBtree; // The leaf node.
  }
  else {
    template __Lambda1(alias left) {
      template __Lambda2(alias right) {
        alias MakeNode!(depth, tuple(left, right)) __Lambda2;
      }

      alias Bind!(BuildBtree!(depth-1), __Lambda2) __Lambda1;
    }

    alias Bind!(BuildBtree!(depth-1), __Lambda1) BuildBtree;
  }
}

This part is a little less readable as there are no anonymous templates in D (what would that even be?).
I won’t bother explaining this snippet as it’s pretty involved, it contains nested templates, template aliases, static conditionals and a standard library defined tuple – several of D’s numerous template goodies.

Just enjoy it. <3

Lastly, we need to “run” the monad and output it to the console:

template RunMonad(alias M, alias counter) {
  alias M!counter RunMonad;
}

void main() {
  enum numberedBinaryTree = RunMonad!(BuildBtree!3, 100);
  pragma(msg, numberedBinaryTree);
}

This code creates a numberedBinaryTree of depth 3, each node with a unique identifier starting with 100.
I used pragma(msg, …) to output the tree just to make it clear that it was, indeed, created at compile time.
Here’s the “pretty-formatted” output that shows our binary tree:

Tuple(115, Tuple(
  Tuple(114, 3),Tuple(Tuple(
    Tuple(106, 2), Tuple(Tuple(
      Tuple(102, 1), Tuple(Tuple(
        Tuple(100, 0), "leaf"), Tuple(
        Tuple(101, 0), "leaf"))), Tuple(
      Tuple(105, 1), Tuple(Tuple(
        Tuple(103, 0), "leaf"), Tuple(
        Tuple(104, 0), "leaf"))))), Tuple(
    Tuple(113, 2), Tuple(Tuple(
      Tuple(109, 1), Tuple(Tuple(
        Tuple(107, 0), "leaf"), Tuple(
        Tuple(108, 0), "leaf"))), Tuple(
      Tuple(112, 1), Tuple(Tuple(
        Tuple(110, 0), "leaf"), Tuple(
        Tuple(111, 0), "leaf"))))))))

It may not be as readable as the Scheme version, but that’s a small price to pay.
Now don’t get me wrong, this fairly involved code just shows the capabilities of D’s templates – you can implement such complex ideas as monads very easily. Additionally, it maps nearly directly to the Scheme code.
That’s a yet another reason I like D so much.

BTW, I might write a little more useful monad as a followup to this post, to show that this can be, in fact, useful. Stay tuned.