Category Archives: WSU

Rendering HTML with SXML and GNU Guile

GNU Guile provides modules for working with XML documents called SXML.
SXML provides an elegant way of writing XML documents as s-expressions
that can be easily manipulated in Scheme. Here’s an example:

(sxml->xml '(foo (bar (@ (attr "something")))))

<foo><bar attr="something" /></foo>

I don’t know about you, but I work with HTML documents much more often
than XML. Since HTML is very similar to XML, we should be able to
represent it with SXML, too!

(sxml->xml '(html
             (head
              (title "Hello, world!")
              (script (@ (src "foo.js"))))
             (body
              (h1 "Hello!"))))

<html>
  <head>
    <title>Hello, world!</title>
    <script src="foo.js" /> <!-- what? -->
  </head>
  <body>
    <h1>Hello!</h1>
  </body>
</html>

That <script> tag doesn’t look right! Script tags don’t close
themselves like that. Well, we could hack around it:

(sxml->xml '(html
             (head
              (title "Hello, world!")
              (script (@ (src "foo.js")) ""))
             (body
              (h1 "Hello!"))))

<html>
  <head>
    <title>Hello, world!</title>
    <script src="foo.js"></script>
  </head>
  <body>
    <h1>Hello!</h1>
  </body>
</html>

Note the use of the empty string in (script (@ (src "foo.js"))
""). The output looks correct now, great! But what about the other
void elements? We’ll have to remember to use the empty string hack
each time we use one. That doesn’t sound very elegant.

Furthermore, text isn’t even escaped properly!

(sxml->xml "Copyright © 2015  David Thompson <davet@gnu.org>")

Copyright © 2015  David Thompson &lt;davet@gnu.org&gt;

The < and > braces were escaped, but © should’ve been
rendered as &copy;. Why does this fail, too? Is there a bug in
SXML?

There’s no bug. The improper rendering happens because HTML, while
similar to XML, has a bunch of different syntax rules. Instead of
using sxml->xml, a new procedure that is tailored to the HTML
syntax is needed. Introducing sxml->html:

(define* (sxml->html tree #:optional (port (current-output-port)))
  "Write the serialized HTML form of TREE to PORT."
  (match tree
    (() *unspecified*)
    (('doctype type)
     (doctype->html type port))
    ;; Unescaped, raw HTML output
    (('raw html)
     (display html port))
    (((? symbol? tag) ('@ attrs ...) body ...)
     (element->html tag attrs body port))
    (((? symbol? tag) body ...)
     (element->html tag '() body port))
    ((nodes ...)
     (for-each (cut sxml->html <> port) nodes))
    ((? string? text)
     (string->escaped-html text port))
    ;; Render arbitrary Scheme objects, too.
    (obj (object->escaped-html obj port))))

In addition to being aware of void elements and escape characters, it
can also render '(doctype "html") as <!DOCTYPE html>, or
render an unescaped HTML string using '(raw "frog &amp; toad").

Here’s the full version of my (sxml html) module. It’s quite
brief, if you don’t count the ~250 lines of escape codes! This code
requires Guile 2.0.11 or greater.

Happy hacking!

(define-module (sxml html)
  #:use-module (sxml simple)
  #:use-module (srfi srfi-26)
  #:use-module (ice-9 match)
  #:use-module (ice-9 format)
  #:use-module (ice-9 hash-table)
  #:export (sxml->html))

(define %void-elements
  '(area
    base
    br
    col
    command
    embed
    hr
    img
    input
    keygen
    link
    meta
    param
    source
    track
    wbr))

(define (void-element? tag)
  "Return #t if TAG is a void element."
  (pair? (memq tag %void-elements)))

(define %escape-chars
  (alist->hash-table
   '((#" . "quot")
     (#& . "amp")
     (#' . "apos")
     (#< . "lt")
     (#> . "gt")
     (#¡ . "iexcl")
     (#¢ . "cent")
     (#£ . "pound")
     (#¤ . "curren")
     (#¥ . "yen")
     (#¦ . "brvbar")
     (#§ . "sect")
     (#¨ . "uml")
     (#© . "copy")
     (#ª . "ordf")
     (#« . "laquo")
     (#¬ . "not")
     (#® . "reg")
     (#¯ . "macr")
     (#° . "deg")
     (#± . "plusmn")
     (#² . "sup2")
     (#³ . "sup3")
     (#´ . "acute")
     (#µ . "micro")
     (# . "para")
     (#· . "middot")
     (#¸ . "cedil")
     (#¹ . "sup1")
     (#º . "ordm")
     (#» . "raquo")
     (#¼ . "frac14")
     (#½ . "frac12")
     (#¾ . "frac34")
     (#¿ . "iquest")
     (#À . "Agrave")
     (#Á . "Aacute")
     (#Â . "Acirc")
     (#Ã . "Atilde")
     (#Ä . "Auml")
     (#Å . "Aring")
     (#Æ . "AElig")
     (#Ç . "Ccedil")
     (#È . "Egrave")
     (#É . "Eacute")
     (#Ê . "Ecirc")
     (#Ë . "Euml")
     (#Ì . "Igrave")
     (#Í . "Iacute")
     (#Î . "Icirc")
     (#Ï . "Iuml")
     (#Ð . "ETH")
     (#Ñ . "Ntilde")
     (#Ò . "Ograve")
     (#Ó . "Oacute")
     (#Ô . "Ocirc")
     (#Õ . "Otilde")
     (#Ö . "Ouml")
     (#× . "times")
     (#Ø . "Oslash")
     (#Ù . "Ugrave")
     (#Ú . "Uacute")
     (#Û . "Ucirc")
     (#Ü . "Uuml")
     (#Ý . "Yacute")
     (#Þ . "THORN")
     (#ß . "szlig")
     (#à . "agrave")
     (#á . "aacute")
     (#â . "acirc")
     (#ã . "atilde")
     (#ä . "auml")
     (#å . "aring")
     (#æ . "aelig")
     (#ç . "ccedil")
     (#è . "egrave")
     (#é . "eacute")
     (#ê . "ecirc")
     (#ë . "euml")
     (#ì . "igrave")
     (#í . "iacute")
     (#î . "icirc")
     (#ï . "iuml")
     (#ð . "eth")
     (#ñ . "ntilde")
     (#ò . "ograve")
     (#ó . "oacute")
     (#ô . "ocirc")
     (#õ . "otilde")
     (#ö . "ouml")
     (#÷ . "divide")
     (#ø . "oslash")
     (#ù . "ugrave")
     (#ú . "uacute")
     (#û . "ucirc")
     (#ü . "uuml")
     (#ý . "yacute")
     (#þ . "thorn")
     (#ÿ . "yuml")
     (#Π. "OElig")
     (#œ . "oelig")
     (#Š . "Scaron")
     (#š . "scaron")
     (#Ÿ . "Yuml")
     (#ƒ . "fnof")
     (#ˆ . "circ")
     (#˜ . "tilde")
     (#Α . "Alpha")
     (#Β . "Beta")
     (#Γ . "Gamma")
     (#Δ . "Delta")
     (#Ε . "Epsilon")
     (#Ζ . "Zeta")
     (#Η . "Eta")
     (#Θ . "Theta")
     (#Ι . "Iota")
     (#Κ . "Kappa")
     (#Λ . "Lambda")
     (#Μ . "Mu")
     (#Ν . "Nu")
     (#Ξ . "Xi")
     (#Ο . "Omicron")
     (#Π . "Pi")
     (#Ρ . "Rho")
     (#Σ . "Sigma")
     (#Τ . "Tau")
     (#Υ . "Upsilon")
     (#Φ . "Phi")
     (#Χ . "Chi")
     (#Ψ . "Psi")
     (#Ω . "Omega")
     (#α . "alpha")
     (#β . "beta")
     (#γ . "gamma")
     (#δ . "delta")
     (#ε . "epsilon")
     (#ζ . "zeta")
     (#η . "eta")
     (#θ . "theta")
     (#ι . "iota")
     (#κ . "kappa")
     (#λ . "lambda")
     (#μ . "mu")
     (#ν . "nu")
     (#ξ . "xi")
     (#ο . "omicron")
     (#π . "pi")
     (#ρ . "rho")
     (#ς . "sigmaf")
     (#σ . "sigma")
     (#τ . "tau")
     (#υ . "upsilon")
     (#φ . "phi")
     (#χ . "chi")
     (#ψ . "psi")
     (#ω . "omega")
     (#ϑ . "thetasym")
     (#ϒ . "upsih")
     (#ϖ . "piv")
     (#  . "ensp")
     (#  . "emsp")
     (#  . "thinsp")
     (#– . "ndash")
     (#— . "mdash")
     (#‘ . "lsquo")
     (#’ . "rsquo")
     (#‚ . "sbquo")
     (#“ . "ldquo")
     (#” . "rdquo")
     (#„ . "bdquo")
     (#† . "dagger")
     (#‡ . "Dagger")
     (#• . "bull")
     (#… . "hellip")
     (#‰ . "permil")
     (#′ . "prime")
     (#″ . "Prime")
     (#‹ . "lsaquo")
     (#› . "rsaquo")
     (#‾ . "oline")
     (#⁄ . "frasl")
     (#€ . "euro")
     (#ℑ . "image")
     (#℘ . "weierp")
     (#ℜ . "real")
     (#™ . "trade")
     (#ℵ . "alefsym")
     (#← . "larr")
     (#↑ . "uarr")
     (#→ . "rarr")
     (#↓ . "darr")
     (#↔ . "harr")
     (#↵ . "crarr")
     (#⇐ . "lArr")
     (#⇑ . "uArr")
     (#⇒ . "rArr")
     (#⇓ . "dArr")
     (#⇔ . "hArr")
     (#∀ . "forall")
     (#∂ . "part")
     (#∃ . "exist")
     (#∅ . "empty")
     (#∇ . "nabla")
     (#∈ . "isin")
     (#∉ . "notin")
     (#∋ . "ni")
     (#∏ . "prod")
     (#∑ . "sum")
     (#− . "minus")
     (#∗ . "lowast")
     (#√ . "radic")
     (#∝ . "prop")
     (#∞ . "infin")
     (#∠ . "ang")
     (#∧ . "and")
     (#∨ . "or")
     (#∩ . "cap")
     (#∪ . "cup")
     (#∫ . "int")
     (#∴ . "there4")
     (#∼ . "sim")
     (#≅ . "cong")
     (#≈ . "asymp")
     (#≠ . "ne")
     (#≡ . "equiv")
     (#≤ . "le")
     (#≥ . "ge")
     (#⊂ . "sub")
     (#⊃ . "sup")
     (#⊄ . "nsub")
     (#⊆ . "sube")
     (#⊇ . "supe")
     (#⊕ . "oplus")
     (#⊗ . "otimes")
     (#⊥ . "perp")
     (#⋅ . "sdot")
     (#⋮ . "vellip")
     (#⌈ . "lceil")
     (#⌉ . "rceil")
     (#⌊ . "lfloor")
     (#⌋ . "rfloor")
     (#〈 . "lang")
     (#〉 . "rang")
     (#◊ . "loz")
     (#♠ . "spades")
     (#♣ . "clubs")
     (#♥ . "hearts")
     (#♦ . "diams"))))

(define (string->escaped-html s port)
  "Write the HTML escaped form of S to PORT."
  (define (escape c)
    (let ((escaped (hash-ref %escape-chars c)))
      (if escaped
          (format port "&~a;" escaped)
          (display c port))))
  (string-for-each escape s))

(define (object->escaped-html obj port)
  "Write the HTML escaped form of OBJ to PORT."
  (string->escaped-html
   (call-with-output-string (cut display obj <>))
   port))

(define (attribute-value->html value port)
  "Write the HTML escaped form of VALUE to PORT."
  (if (string? value)
      (string->escaped-html value port)
      (object->escaped-html value port)))

(define (attribute->html attr value port)
  "Write ATTR and VALUE to PORT."
  (format port "~a="" attr)
  (attribute-value->html value port)
  (display #" port))

(define (element->html tag attrs body port)
  "Write the HTML TAG to PORT, where TAG has the attributes in the
list ATTRS and the child nodes in BODY."
  (format port "<~a" tag)
  (for-each (match-lambda
             ((attr value)
              (display #space port)
              (attribute->html attr value port)))
            attrs)
  (if (and (null? body) (void-element? tag))
      (display " />" port)
      (begin
        (display #> port)
        (for-each (cut sxml->html <> port) body)
        (format port "</~a>" tag))))

(define (doctype->html doctype port)
  (format port "<!DOCTYPE ~a>" doctype))

(define* (sxml->html tree #:optional (port (current-output-port)))
  "Write the serialized HTML form of TREE to PORT."
  (match tree
    (() *unspecified*)
    (('doctype type)
     (doctype->html type port))
    ;; Unescaped, raw HTML output
    (('raw html)
     (display html port))
    (((? symbol? tag) ('@ attrs ...) body ...)
     (element->html tag attrs body port))
    (((? symbol? tag) body ...)
     (element->html tag '() body port))
    ((nodes ...)
     (for-each (cut sxml->html <> port) nodes))
    ((? string? text)
     (string->escaped-html text port))
    ;; Render arbitrary Scheme objects, too.
    (obj (object->escaped-html obj port))))

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

Reproducible Development Environments with GNU Guix

If you’re a software developer, then you probably know very well that
setting up a project’s development environment for the first time can
be a real pain. Installing all of the necessary dependencies using
your system’s package manager can be very tedious. To "solve" this
problem, we have resorted to inventing new package managers and
dependency bundlers for pretty much every programming language. Ruby
has rubygems and bundler, Python has pip and virtualenv, PHP has
composer, node.js has npm, and so on. Wouldn’t it be nice to instead
have a single package manager that can handle it all? Enter GNU
Guix, a purely functional package manager and GNU/Linux
distribution. Using Guix, you can easily create a development
environment for any software project using the guix environment
tool.

guix environment is a new utility added in Guix 0.8, which should
be released in a few weeks. It accepts one on more packages as input
and produces a new shell environment in which all of the dependencies
for those packages are made available. For example, guix
environment emacs will get you everything you need to build GNU
Emacs from a source release tarball. By default, your $SHELL is
spawned, but you may opt to use any arbitrary shell command instead.
If you’ve used Nix before, you may notice that this sounds exactly
like nix-shell, and that’s because it was what inspired me to
write guix environment.

Now, let’s take a look at an example. One of my hobby projects is
Sly, a game engine written in Guile Scheme. Here’s the relevant Guix
code that will produce a complete development environment:

;;; Copyright (C) 2014 David Thompson <davet@gnu.org>
;;;
;;; Sly is free software: you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation, either version 3 of the License, or
;;; (at your option) any later version.

(use-modules (guix packages)
             (guix licenses)
             (guix build-system gnu)
             (gnu packages)
             (gnu packages autotools)
             (gnu packages guile)
             (gnu packages gl)
             (gnu packages pkg-config)
             (gnu packages sdl)
             (gnu packages maths)
             (gnu packages image))

;; The development environment needs a tweaked LD_LIBRARY_PATH for
;; finding libfreeimage.
(define freeimage
  (package (inherit freeimage)
    (native-search-paths
     (list (search-path-specification
            (variable "LD_LIBRARY_PATH")
            (directories '("lib")))))))

(package
  (name "sly")
  (version "0.0")
  (source #f)
  (build-system gnu-build-system)
  (inputs
   `(("pkg-config" ,pkg-config)
     ("autoconf" ,autoconf)
     ("automake" ,automake)
     ("guile" ,guile-2.0)
     ("guile-sdl" ,guile-sdl)
     ("guile-opengl" ,guile-opengl)
     ("gsl" ,gsl)
     ("freeimage" ,freeimage)
     ("mesa" ,mesa)))
  (synopsis "2D/3D game engine for GNU Guile")
  (description "Sly is a 2D/3D game engine written in Guile Scheme.
Sly differs from most game engines in that it emphasizes functional
reactive programming and live coding.")
  (home-page "https://gitorious.org/sly/sly")
  (license gpl3+))

You may have noticed that the source field has been set to false.
This is because the package is not for building and installing. It’s
sole purpose is to provide the necessary software needed to build Sly
from a fresh git checkout.

Assuming this code is in a file called package.scm, you can simply
run guix environment -l package.scm to spawn a shell for hacking
on Sly. By default, the environment created is an augmented version
of your pre-existing shell’s environment. This is convenient when you
want to use your installed software in the new environment, such as
git. However, it’s important to make sure that the environment really
does have everything needed for development without relying on any
impurities introduced by your existing environment. Without verifying
this, new developers might be frustrated to find out that the
environment provided to them is incomplete. To verify, pass the
--pure flag and build from scratch.

So, guix environment is a pretty nice way to acquire all the
dependencies you need to work on a project, but there is still a lot
of room for improvement. What if you were working on a web
application that required a running PostgreSQL database, Redis server,
and XMPP server? It would be really great if Guix could handle
setting this up for you, too, a la Vagrant. To do so, guix
environment could use the existing features of guix system to
spawn a new virtual machine that shared the host system’s package
store and the project’s source tree, and then spawn a shell with your
development environment. I hope to implement this in the
not-too-distant future. Until next time, happy hacking!

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

Guile-2D is now named "Sly"

Guile-2D the a working title for my game engine written in Guile
Scheme. The name has become very limiting since I realized that it
wouldn’t be much extra work to support 3D graphics. After much
indecision, I’ve finally decided on an official name: Sly. I think
it’s a great name. It’s short, easy to type, and slyness is one of
the definitions of “guile”.

In other news:

  • Sly has a new contributor!
    Jordan Russel has written a
    new module
    that provides joystick input support.

  • I have written a
    module for describing animations.

  • I have been slowly working on a scene graph implementation that
    plays well with the functional reactive programming API.

  • As mentioned above, 3D graphics support is on the way! So far, I
    have implemented a perspective projection matrix, a “look at”
    matrix, and a cube primitive.

3D Scene Graph

Check out the Sly source code repository on
Gitorious!

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

Live Asset Reloading with guile-2d

Guile-2d provides a dynamic environment in which a developer can build
a game incrementally as it runs via the Guile REPL. It’s nice to be
able to hot-swap code and have the running game reflect the changes
made, but what about the game data files? If an image file or other
game asset is modified, it would be nice if the game engine took
notice and reloaded it automatically. This is what guile-2d’s live
asset reloading feature does.

The new (2d live-reload) module provides the live-reload
procedure. live-reload takes a procedure like load-texture
and returns a new procedure that adds the live reload magic. The new
procedure returns assets wrapped in a signal, a time-varying value. A
coroutine is started that periodically checks if the asset file has
been modified, and if so, reloads the asset and propagates it via the
signal. Game objects that depend on the asset will be regenerated
immediately.

Here’s some example code:

(define load-texture/live
  (live-reload load-texture))

(define-signal texture
  (load-texture/live "images/p1_front.png"))

(define-signal sprite
  (signal-map
   (lambda (texture)
     (make-sprite texture
                  #:position (vector2 320 240)))
   texture))

load-texture/live loads textures and reloads them when they change
on disk. Every time the texture is reloaded, the sprite is
regenerated using the new texture.

Here’s a screencast to see live reloading in action:

Guile-2d is ever-so-slowly approaching a 0.2 release. Stay tuned!

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

Functional Reactive Programming in Scheme with guile-2d

Last month, the GNU Guile project celebrated the 3rd anniversary of
its 2.0 release with a hacker potluck. Guilers were encouraged to
bring a tasty hack to the mailing list to share with everyone. My
dish was a simple functional reactive programming library.

Functional reactive programming (FRP) provides a way to describe
time-varying values and their relationships using a functional and
declarative programming style. To understand what this means, let’s
investigate a typical variable definition in Scheme. The expression
(define c (+ a b)) defines the variable c to be the sum of
variables a and b at the time of evaluation. If a or
b is assigned a new value, c remains the same. However, for
applications that deal with state that transforms over time, it would
be convenient if we could define c to react to changes in a
and b by recomputing the sum. Contrast this approach with the
more traditional style of modeling dynamic state via events and
callbacks. A lot of programmers, myself included, have written code
with so many callbacks that the resulting program is unmaintainable
spaghetti code. Callback hell is real, but if you accept FRP into
your heart then you will be saved!

By now you’re probably wondering: "What the hell does all this mean?"
So, here’s a real-world example of guile-2d’s FRP API:

(define-signal position
  (signal-fold v+ (vector2 320 240)
               (signal-map (lambda (v)
                             (vscale v 4))
                           (signal-sample game-agenda 1 key-arrows))))

In guile-2d, time-varying values are called "signals". The above
signal describes a relationship between the arrow keys on the keyboard
and the position of the player. signal-sample is used to trigger
a signal update upon every game tick that provides the current state
of the arrow keys. key-arrows is a vector2 that maps to the
current state of the arrow keys, allowing for 8 direction movement.
This vector2 is then scaled 4x to make the player move faster.
Finally, the scaled vector is added to the previous player position
via signal-fold. The player’s position is at (320, 240)
initially. As you can see, there are no callbacks and explicit
mutation needed. Those details have been abstracted away, freeing the
programmer to focus on more important things.

I think it’s helpful to see FRP in action to really appreciate the
magic. So, check out this screencast!

To see all of the juicy implementation details, check out the git
repository. Thanks for following along!

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

A Cooperative REPL Server for Guile 2.0.10

The next release of GNU Guile, 2.0.10, is to be released "real soon
now". My contribution to this release is the new (system repl
coop-server) module. This module introduces a useful variant of the
REPL server that I’ve named the "cooperative" REPL server. It is
cooperative because it can be integrated with single-threaded programs
without the thread synchronization issues present in the ordinary REPL
server.

Using delimited continuations and mvars (another new feature coming in
Guile 2.0.10), it was possible to create a REPL server whose clients
all ran in the context of a single thread. The cooperative server
puts the user in control of when it is safe to evaluate expressions
entered at the REPL prompt.

Here’s an example of how to use it:

(use-modules (system repl coop-server))

(define server (spawn-coop-repl-server))

(while #t
  (poll-coop-repl-server server)
  (sleep 1))

That’s all it takes. There are only 2 public procedures!
spawn-coop-repl-server creates a new cooperative REPL server
object and starts listening for clients. poll-coop-repl-server
applies pending operations for the server.

Now that I’ve explained the API, onto the implementation details!
Although the REPLs run in the context of a single thread, there are
other threads needed to make it all work. To avoid thinking too much
about thread synchronization issues, I used the new (ice-9 mvars)
module to provide thread-safe objects for read/write operations. I
used delimited continuations in order to yield control back to the
user from inside the loop.

When the server is spawned, a new thread is created to listen for
client connections. When a client connects, a request to create a new
REPL is put into the server’s "evaluation" mvar, the storage place for
pending server operations. The job of poll-coop-repl-server is to
attempt to take from the evaluation mvar and execute the operation
stored within, if any. In this case, an operation called new-repl
is hanging out along with the client socket. The contents of the mvar
are removed, and a new REPL is started in the main thread.

This new REPL is run within a "prompt", Guile’s implementation of
delimited continuations. The prompt allows the REPL to be paused
temporarily while waiting for user input. Just before the prompt is
aborted, a thunk containing the logic to read user input is stored
within the client’s "read" mvar for yet another thread to use.
Without this additional thread and the use of a prompt, the main
thread would block while waiting for input, defeating the purpose of
the cooperative REPL. The reader thread waits for this thunk to
appear in the read mvar. When it appears, the thunk is applied and
the resulting expression is stored as an eval operation within the
evaluation mvar. When poll-coop-repl-server is called, the REPL
prompt is resumed. The input expression is evaluated in the context
of the main thread, the result is printed, and the process repeats
itself.

That’s all, folks. Thanks for following along. I’m very excited to
use the cooperative REPL server in guile-2d and I hope that others
find it useful as well. Many thanks to Mark Weaver for helping me out
when I got stuck and for all of the helpful code review.

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

Syncing Required Packages in Emacs

I use Emacs on several different computers. To keep my configuration
consistent across all of them, I do what many people do and made the
~/.emacs.d directory a git repository. I don’t like to keep
copies of all of the Elisp extensions that I use, such as paredit and
geiser, in this repository. Instead, I prefer to use package.el
(introduced in Emacs 24) with the MELPA repository. This saves me
from having to manually keep all of the extensions I use up-to-date,
but requires another method to keep useful packages in sync between
computers.

There’s a project called Pallet that solves this problem, but it was
too heavy for my liking. Instead, I wrote a short function that
simply iterates over a list of required packages and installs those
that are not currently installed.

;; Additional packages that I use.
 (setq required-packages
       '(better-defaults
         elfeed
         geiser
         ido-ubiquitous
         js2-mode
         magit
         paredit
         rainbow-delimiters
         smex))

 (defun install-missing-packages ()
   "Install all required packages that haven't been installed."
   (interactive)
   (mapc (lambda (package)
           (unless (package-installed-p package)
             (package-install package)))
         required-packages)
   (message "Installed all missing packages!"))

Now, it’s as easy as typing M-x install-missing-packages RET when
starting Emacs for the first time on a new computer to download all of
the extensions that I need. Note that before calling
install-missing-packages you must have already initialized the
package manager via the package-initialize function. This
approach does require some manual bookkeeping in order to keep the
required-packages list up-to-date with your workflow, but I
haven’t found it to be problematic.

Update: If this solution is too simplistic for you, you should check
out use-package, which reddit user lunayorn pointed out to
me. Thanks!

Check out the comments on reddit.

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

Jump to Jasmine Specs with Rinari

I use the rinari Emacs mode to assist me when working on rails
projects. One of rinari’s most useful features is the ability to
quickly jump from one file to another related file. I use this
feature almost exclusively for jumping between a ruby class file and
its associated rspec file, but lately I’ve been spending most of my
time writing javascript. At VHL, we use jasmine for our unit testing
framework and the jasmine ruby gem to integrate it with our rails
projects. Rinari doesn’t have any built-in jump settings for jasmine
test files, so I wrote this quick hack to make it work:

;; Make rinari jump to/from javascript source files and specs.
(setcdr (assoc 'javascript rinari-jump-schema)
        '("j"
          (("app/assets/javascripts/\\1.js" . "spec/javascripts/\\1_spec.js")
           ("spec/javascripts/\\1_spec.js"  . "app/assets/javascripts/\\1.js")
           (t . "spec/javascripts/.*")
           (t . "app/javascripts/.*"))
          t))
(rinari-apply-jump-schema rinari-jump-schema)

Now I can press C-c ; f j to jump between a javascript file in
app/assets/javascripts/ and its jasmine test file in
spec/javascripts/. Perhaps I shouldn’t be overwriting the
predefined (but not very useful) javascript jump settings, but I
really wanted to use the j key.

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

First GNU Guile Patch and More Guix Packages

I have spent some of the last month working on contributing to GNU
Guile and now I can finally say that I have contributed code to the
project. Guile has several hash table implementations: a Guile native
one, SRFI-69, and R6RS. SRFI-69 contains a handy procedure,
alist->hash-table, which allows for a sort of hash literal-like
syntax:

(alist->hash-table
 '((foo . 1)
   (bar . 2)
   (baz . 3)))

However, I prefer to use Guile’s native hash implementation, and
SRFI-69 is incompatible with it, so I decided to port
alist->hash-table. Unfortunately, it was not as simple as writing
just one procedure. The native hash tables actually have 4 different
ways of doing key comparisons: Using equal?, eq?, eqv?,
and user-defined procedures. This is a design flaw because the user
must make sure to use the right procedures at all times rather than
simply set the hash and assoc procedures when creating the
hash table instance.

Below is the final implementation. Since 3 of the 4 variations were
essentially the same, I wrote a short macro to reduce code
duplication.

;;;; Copyright (C) 2013 Free Software Foundation, Inc.
;;;;
;;;; This library is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU Lesser General Public
;;;; License as published by the Free Software Foundation; either
;;;; version 3 of the License, or (at your option) any later version.
;;;;
;;;; This library is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;;; Lesser General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Lesser General Public
;;;; License along with this library; if not, write to the Free Software
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
;;;;

(define-syntax-rule (define-alist-converter name hash-set-proc)
  (define (name alist)
    "Convert ALIST into a hash table."
    (let ((table (make-hash-table)))
      (for-each (lambda (pair)
                  (hash-set-proc table (car pair) (cdr pair)))
                (reverse alist))
      table)))

(define-alist-converter alist->hash-table hash-set!)
(define-alist-converter alist->hashq-table hashq-set!)
(define-alist-converter alist->hashv-table hashv-set!)

(define (alist->hashx-table hash assoc alist)
  "Convert ALIST into a hash table with custom HASH and ASSOC
procedures."
  (let ((table (make-hash-table)))
    (for-each (lambda (pair)
                (hashx-set! hash assoc table (car pair) (cdr pair)))
              (reverse alist))
    table))

Not only did I manage to get my code into Guile, I was given commit
access to GNU Guix by the lead developer, Ludovic Courtès. I have
never had commit access to any free software project repositories
besides my own. I feel quite honored, as cheesy as that may sound.

Packages for SDL and SDL2 have been merged into master, and packages
for SDL_gfx, SDL_image, SDL_mixer, SDL_net, and SDL_ttf for SDL 1.2
are pending review.

I like to show off the elegance of Guix package recipes, so here’s
some code:

;;; Copyright © 2013 David Thompson <dthompson2@worcester.edu>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define sdl
  (package
    (name "sdl")
    (version "1.2.15")
    (source (origin
             (method url-fetch)
             (uri
              (string-append "http://libsdl.org/release/SDL-"
                             version ".tar.gz"))
             (sha256
              (base32
               "005d993xcac8236fpvd1iawkz4wqjybkpn8dbwaliqz5jfkidlyn"))))
    (build-system gnu-build-system)
    (arguments '(#:tests? #f)) ; no check target
    (inputs `(("libx11" ,libx11)
              ("libxrandr" ,libxrandr)
              ("mesa" ,mesa)
              ("alsa-lib" ,alsa-lib)
              ("pkg-config" ,pkg-config)
              ("pulseaudio" ,pulseaudio)))
    (synopsis "Cross platform game development library")
    (description "Simple DirectMedia Layer is a cross-platform development
library designed to provide low level access to audio, keyboard, mouse,
joystick, and graphics hardware.")
    (home-page "http://libsdl.org/")
    (license lgpl2.1)))

(define sdl2
  (package (inherit sdl)
    (name "sdl2")
    (version "2.0.0")
    (source (origin
             (method url-fetch)
             (uri
              (string-append "http://libsdl.org/release/SDL2-"
                             version ".tar.gz"))
             (sha256
              (base32
               "0y3in99brki7vc2mb4c0w39v70mf4h341mblhh8nmq4h7lawhskg"))))
    (license bsd-3)))

Much help is needed to package the GNU system for Guix. If you are
interested in helping, please drop by #guix on freenode, we are
friendly. 🙂

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.

My First GNU Guix Patch

Over the weekend, I decided to try out GNU Guix: A fully functional
package manager based on Nix and a distribution of the GNU system. I’m
a big proponent of GNU Guile, thus I was excited to see a DSL for
package management written with Guile.

I was told that libtheora would be pretty easy to package, and it
was. Here’s what the package definition looks like:

(define libtheora
  (package
    (name "libtheora")
    (version "1.1.1")
    (source (origin
             (method url-fetch)
             (uri (string-append "http://downloads.xiph.org/releases/theora/libtheora-"
                                 version ".tar.xz"))
             (sha256
              (base32
               "0q8wark9ribij57dciym5vdikg2464p8q2mgqvfb78ksjh4s8vgk"))))
    (build-system gnu-build-system)
    (inputs `(("libvorbis" ,libvorbis)))
    ;; The .pc files refer to libogg.
    (propagated-inputs `(("libogg" ,libogg)))
    (synopsis "Library implementing the Theora video format")
    (description
     "The libtheora library implements the ogg theora video format,
a fully open, non-proprietary, patent-and-royalty-free, general-purpose
compressed video format.")
    (license license:bsd-3)
    (home-page "http://xiph.org/theora/")))

Pretty slick, eh? Now, I’m starting to work on packaging SDL (1.2
and 2) and the SDL extensions (gfx, ttf, etc.), which are not quite as
easy. I hope to package all of the dependencies that guile-2d will
need to be available as a Guix package.

From the blog dthompson by David Thompson and used with permission of the author. All other rights reserved by the author.