It struck me that a linux keylogger is perfectly easy to write – I had previously (naïvely) thought such a program would only work given root permissions.

Alas! It’s stupidly easy.

see result of 30 minutes of hacking

The code simply calls xinput test [id of keyboard device] and parses out the keycodes. The id of your keyboard device can be found from the device listing given by xinput list.

Whilst writing, I became a bit distracted, and decided to write some haskell to print 1D automata. After replacing most variables with single letters, and manually inlining some things, behold:

import Data.Bits
ns xs = zip3 (drop (l-1) xs') xs (tail xs') where xs' = cycle xs; l = length xs
s ru xs = map (\(l,c,r) -> if (2^(l*4 + c*2 + r) .&. ru) == 0 then 0 else 1) $ ns xs
ss = map (\c -> if c == 0 then ' ' else '#')
printAutomata :: Int -> Int -> [Int] -> IO () --one type sig needed
printAutomata n r xs = mapM_ putStrLn $ map ss $ take n $ iterate (s r) xs


Then in GHCI, let’s try to simulate Rule 90 starting with a single cell of state 1.

Prelude> :l ca.hs
[1 of 1] Compiling Main             ( ca.hs, interpreted )
Ok, modules loaded: Main.
*Main> printAutomata 20 90 $ (replicate 20 0) ++ [1] ++ (replicate 20 0)
                    #
                   # #
                  #   #
                 # # # #
                #       #
               # #     # #
              #   #   #   #
             # # # # # # # #
            #               #
           # #             # #
          #   #           #   #
         # # # #         # # # #
        #       #       #       #
       # #     # #     # #     # #
      #   #   #   #   #   #   #   #
     # # # # # # # # # # # # # # # #
    #                               #
   # #                             # #
  #   #                           #   #
 # # # #                         # # # #

Yay Sierpinski!

I wanted a way to test and play with this API from the console. A search threw up HTTY: the HTTP TTY, which is a fantastic HTTP console and makes testing a breeze.

One can cd between urls, build and clear query string with query-set and query-clear and use the HTTP verbs.

An example session


http://localhost:8080/api> query-set key aglib29rbWFya3NyDgsSCEJvb2ttYXJrGAMM
http://localhost:8080/api?key=aglib29rbWFya3NyDgsSCEJvb2ttYXJrGAMM> get
200 OK -- 6 headers -- 328-character body
http://localhost:8080/api?key=aglib29rbWFya3NyDgsSCEJvb2ttYXJrGAMM> body
[{"user_tags": ["omg", "lol", "google", "123"], "created": "Fri Dec 24 18:42:42 2010", "_key": "aglib29rbWFya3NyDgsSCEJvb2ttYXJrGAMM", "title": "lol", "access": "public", "link": {"_key": "aglib29rbWFya3NyCgsSBExpbmsYAgw", "url": "http:\/\/www.lol.com\/"}, "user": {"nickname": "test@example.com", "email": "test@example.com"}}]


Turns out a very simple quine (no attempt be concise) is.. very simple.

import zlib
data = b'x\x9c\xcb\xcc-\xc8/*Q\xa8\xca\xc9L\xe2JI,IT\xb0U\xa86\xa8\xe5*(\xca\xcc+\xd1\x00\x89\xea\xa5\xa4&\xe7\xe7\x16\x14\xa5\x16\x17k\x80\x14h\x82\x05RR5\xd4KK\xd2t-\xd45\xf5\xd2\xf2\x8br\x13K \x92\x9a\x00\x82\x1e\x1b\xc4'
print(zlib.decompress(data).decode('utf-8').format(data))

The data section is result of compressing the string:

import zlib
data = {0}
print(zlib.decompress(data).decode('utf-8').format(data))

and so we decompress the data and replace {0} with what the data is.

let be a finite dimensional real inner product space.
let be a subspace of V.

Definition

The annihilator of , denoted where is the dual space of V.

Definition

The perpendicular space of , denoted

It might already be apparent that there is some connection between these two – both involve things going to zero, whenever something is done to everything in .

To make this more explicit, first we need a theorem.

Theorem: (weaker version of) Riesz Representation Theorem

is an isomorphism of vector spaces. Restated, we can associate each linear map uniquely with a vector such that .

Proof:

Linearity:

let




and hence we see this is a linear map.

Injectivity:

Suppose
then
so specifically
thus by positive definiteness, hence is injective.

Surjectivity:

Since we have that this is an injective linear map between spaces of the same dimension, this follows by Rank Nullity. Alternatively:
let
take a basis
then define
and we can check that this works.

Now to use this theorem to show the connection.

but for some .
thus

So we have the result we wanted:

Applications

This means all of those oh-so-fun identities one derives for annihilator subspace structure can be passed over to perpendicular subspace structure!

Example:

Given the identity
we can deduce
linearity of gives us
so by injectivity of we have

i.e. compare

to

Since we can keep things general in the theory, I’m going to take
duals over a general type a. Maybe I should look into the mathematical
prelude so that I will be able to specify a to be a ring, but that’s
for another day.

> data Dual a = D a a deriving Show

Some Notation

I shall also slip in and out of the notation to represent the Dual (D a b).

We could maybe use some utility functions to give us the ‘real’ and ‘dual’ parts

> real, dual :: Dual a -> a
> real (D a _) = a
> dual (D _ b) = b

In some ways, we can consider these as an analogue of the complex numbers,
but instead with . Anyhow, equality comes naturally as follows.
(We could get this from the polynomial definition using the coset definition of
equality)

> instance Eq a => Eq (Dual a) where
> (D a b) == (D c d) = (a == c) && (b == d)

Now, we want to treat this as a number.
Since things commute, addition and multiplication come naturally.

> instance Num a => Num (Dual a) where
> (D a b) + (D c d) = D (a+c) (b+d)
> (D a b) * (D c d) = D (a*c) (b*c + a*d)

Again, negation is fairly obvious

> negate (D a b) = D (-a) (-b)

Now Haskell wants us to give a definition for signum – i.e. give
some kind of subset of ‘positive’ duals.
Not sure that this really makes much sense. I’ll leave it undefined for now.

> signum (D a b) = undefined

We also need to give an ‘abs’. Taking inspiration from complex numbers,
if we were to define abs (D a b) to be (D a b)*(D a -b) we end up with

> abs (D a b) = D (abs a) 0

This is all kind of crazy! The complex numbers modulus maps from whereas Haskell requires us to give a function from Duals to Duals. I can’t seem to see anywhere what properties such an abs function should have.

Haskell’s implementation of complex numbers does seem to give something similar to my implementation.

For now then, I’ll just use the definition given here: http://en.wikipedia.org/wiki/Automatic_differentiation#Automatic_differentiation_using_dual_numbers

Finally we need to give a way of converting from integrals to duals – just
take the ‘dual’ part to be 0

> fromInteger n = D (fromIntegral n) 0

Now since Dual numbers are PRETTY MAGIC
– f(D a 1) = D f(a) f’(a)
we can automagically differentiate functions of type Num a => a -> a

> deriv :: Num a => (Dual a -> Dual b) -> a -> b
> deriv f x = dual $ f (D x 1)

Now we could probably do with some notion of division!

but how?!

(D a b) / (D c d) = (D a b) * (D c -d) / c² ?!?!

let’s try and see if crazy happens.

> instance Fractional a => Fractional (Dual a) where
> (D a b) / (D c d) = D (real x / (c*c)) (dual x / (c*c))
> where
> x = (D a b) * (D c (-d))
> fromRational r = D (fromRational r) 0

Everything seems fine!

Now for maybe the more interesting bit, I’d like to implement Duals for
standard functions – sin, cos, … etc
In haskell, this means implementing the Floating class.

> instance Floating a => Floating (Dual a) where

Taking pi to be the Dual with ‘real’ part of pi seems sensible,
though maybe we should ensure that this is still twice the first
‘positive’ root of cos, though quite what positive means.
Since it seems good to have that ,
let us take pi to be

> pi = D pi (2*pi)

Next thing to define is exp. Taking the power series definition,
and noting that

(which follows from binomially expanding and then noting that all other terms contain a .

it follows trivially that

> exp (D a b) = D (exp a) (b*(exp a))

Ok, so maybe something better is happening here.
Why not try a general power series. If we have:

Then we can try sticking in the dual

where we see the dual part is the termwise derivative! Woooop!
so, taking what we already ‘know’ of the derivatives of these functions
(though quite how this is applicable when our underlying Num type isn’t sane)
we get

though, there is a problem in that, since haskell doesn’t ‘know’
these functions are defined in terms of power series, we can’t use
our existing deriv function to produce :(
Lets get cracking then…

> log (D a b) = D (log a) (b*(1/a))
> sin (D a b) = D (sin a) (b*(cos a))
> cos (D a b) = D (cos a) (b*(- sin a))
> sinh (D a b) = D (sinh a) (b*(cosh a))
> cosh (D a b) = D (cosh a) (b*(sinh a))

–leave the inverse trigometric and hyperbolics for now, I’m lazy :D

We can even do crazy things now by taking duals over complex numbers, though
what this ‘means’ I’m not yet sure.

I shall have to think on this.

On the other hand, we are now able to differentiate fairly complicated functions.

> g x = (sin (x * cos (log (1 / (x**2 – 2*x + 3)))))**3
> g’ = deriv g

Published 1996

He sifts through vistas of data and from the chaos identifies nodal points: places where data from various media come together, hinting at the near future.
No. Not Gibson himself, but Laney, a ‘quantitative-analyst’ and one of the protagonists of the novel.

Maybe it’s slightly strange coming to this after reading Gibson’s later work – this book feels almost like a stepping stone between the dark, grittyness of Neuromancer (published 1984) and the fast-paced but somehow much lighter Pattern Recognition (published 2003).

The vision of cyberspace in Idoru is much more concrete, visual than that in The Sprawl trilogy – nearer Snowcrash (Neal Stephenson, 1992) than the neon data-vistas of Neuromancer. Not that this book isn’t Gibson through and through. The focus on the minutae, the tech-heavy slang-heavy vocabulary and the seperate-yet-linked viewpoints.

It will be interesting to see how this fits in with the rest of the Bridge books – I’ve yet to read All Tomorrow’s Parties

Google Chart API supports the creation of images of latex code via urls:

http://chart.apis.google.com/chart?cht=tx&chl=\displaystyle%20exp(x)%20%3D%20\sum_{n%3D0}^{\infty}\frac{x^n}{n!}

kinda messy, right?

It wouldn’t be so good to hardcode this url each time, but using jquery, we can automate this process fairly well.

The Script

Put this somewhere in your page, probably within tags in the head.

function process_latex() {
    $('pre.latex').each(function(e) {
      var tex = $(this).text();
      var url = "http://chart.apis.google.com/chart?cht=tx&chl=" + encodeURIComponent(tex);
      var cls = $(this).attr('class');
      var img = '<img src="' + url + '" alt="' + tex + '" class="' + cls + '"/>';
      $(img).css('display', 'block').insertBefore($(this));
      $(this).hide();
    });
  }

Then make sure the function is called on page load, i.e. add to your $(document).ready handler

$(document).ready(function() {process_latex();});

Usage

Type the latex within <pre class="latex"></pre> tags.
To give more control over styling the resulting images, the images will have whatever classes the

s also have.

Example Usage

<html>
  <head>
    <script src="script/jquery-1.4.2.js"></script>
    <style>
      .latex { vertical-align: middle;} /*default styling for latex imgs */
      .bordered { border: 1px solid red;}
      .block { display: block; }
    </style>

    <script>
      function process_latex() {
        $('pre.latex').each(function(e) {
          var tex = $(this).text();
          var url = "http://chart.apis.google.com/chart?cht=tx&chl=" + encodeURIComponent(tex);
          var cls = $(this).attr('class');
          var img = '<img src="' + url + '" alt="' + tex + '" class="' + cls + '"/>';
          $(img).insertBefore($(this));
          $(this).hide();
        });
      }
      $(document).ready(function() {process_latex();});
    </script>
  </head>
  <body>
    Default look:
    <pre class="latex">
      \sin(x)
    </pre>
    how about an inlined, red bordered formula?
    <pre class="latex bordered">
      \sum_0^\infty \frac{x^n}{n!}
    </pre>
    Very nice! And if we give it the block class?
    <pre class="latex block">
      \int \int_{\mathbb{R}^2} \exp(-x^2 - y^2) dx dy
    </pre>
    See, it went on its own line. Magic!
  </body>
</html>

note: the following assumes that the jQuery library is being used

Google Reader gives any rss/atom feed in JSON format, by visiting the url http://www.google.com/reader/public/javascript/feed/http://www.example.com/feed.rss where http://www.example.com/feed.rss is the url of the feed required as JSON.

An example of the JSON returned for this site’s feed – http://ardoris.wordpress.com/feed/

{"id":"feed/http://ardoris.wordpress.com/feed/",
 "title":"feed/http://ardoris.wordpress.com/feed/",
 "continuation":"CJPduLTt45YC",
 "alternate":{"href":"http://ardoris.wordpress.com","type":"text/html"},
 "updated":1243372714,
 "items":[
   {"id":"tag:google.com,2005:reader/item/be67929ea636a7ad",
     "categories":["General"],"title":"Haskell Snippet – Summing Series #2",
     "published":1243369571,
     "updated":1243369571,
     "alternate":{"href":"http://ardoris.wordpress.com/2009/05/26/haskell-snippet-summing-series-2/",
                      "type":"text/html"},
     "content":"\n\nJust a little hack using show to make the earlier summing series examplelook a bit nicer.\n\nStart with what I had before:\n\nsumseries a b f \u003d sum[f n|n\u003c-[a..b]]\n\nI have swapped around and renamed the arguments a little, just to tidy it up \na tad.\nSumming ...","author":"jebavarde","likingUsers":[],"comments":[],"annotations":[],"origin":{"streamId":"feed/http://ardoris.wordpress.com/feed/","htmlUrl":"http://ardoris.wordpress.com"}},
  < ...more entries here ...>
]};

Processing the feed is therefore as simple as iterating over the items.

Example: listing the titles of all items in the feed in an unordered list of id feed

Put the following somewhere in the of the page

<ul id="feed">

Then in the head, add something like the following:

<script type="text/javascript">
$(document).ready(function() {
  var url = "http://www.google.com/reader/public/javascript/feed/http://ardoris.wordpress.com/feed/?callback=?";
  $.getJSON(url,
                 function(data) {
                   for(var i = 0; i < data.items.length; i += 1)
                     $('#feed').append('<li>' + data.items[i].title + '');
                 });
});
</script>

This can of course be extended by

• adding links to the feed items (to the url found at data.items[i].alternate.href)
• following each title with a content summary (data.items[i].content)
• only processing the first so many entries in the feed (for(var i = 0; i < data.items.length && i < 3; i += 1))

n.b. This can also be used with atom feeds – just pass an atom feed in the url instead