peteriserins.com

Looking back at 2011

peteris.erins@gmail.com (Peteris Erins) — Sun, 01 Jan 2012 00:00:00 EET

Looking back at 2011

01.01.2012

Following a common practice, below is a list of some of the things I did in 2011.

Big picture

Completed first year at University, and first time living abroad
First paid work at Reach.ly
P90X
Started this website (not that big really)

Programming

Learned what a startup is and ended up working at one
Went to three hackathons
Learned a whole bunch of programming/query languages; altogether, I wrote stuff using C++, Java, Javascript, Python, Clojure, Haskell, MATLAB, Ruby, Coffeescript, SQL and played around with bash, PHP, Mathematica, Prolog, C#, Obj-C, Perl, Scheme, Common Lisp, Qi, xslt, xquery
Learned about functional and logic programming, REST, concurrency, databases (SQL and No), browser extensions, mobile development, multiplayer networking. Nice break from my previous algorithmic endeavours

Learning

Did the three online Stanford courses on Artificial Intelligence, Machine Learning and Databases
Some good books I read:
- The Lean Startup
- why’s (poignant) guide to Ruby
- The Elements of Style
- Card Play Technique: The Art of Being Lucky
- Tapworthy
Great books I didn’t finish yet:
- Structure and Interpretation of Computer Programs
- On Lisp
- Dave Pelz’s Short Game Bible
Key research papers and books:
- Push-pull Functional Reactive Programming, C. Elliott
- Logic, Programming and Prolog, U. Nilsson & J. Maluszynski
- Relational Programming in miniKanren: Techniques, Applications, and Implementations, W. E. Byrd
- Latency and Scalability: A Survey of Issues and Techniques for Supporting Networked Games, X. Jiang & F. Safaei & P. Boustead
- and some more at Reach.ly

Hobbies

Helped Cambridge beat the Oxford undergraduates in the annual Varsity bridge match (not quite as fancy as it sounds)
Wrapped up a great college basketball season, and started a bad one
Started rowing
Skied, cycled, ran

Technology

Kindle
Mac
emacs (sorry, Vim)
Mendeley

Outline and targets for 2012

Post more
Read more
Go to a conference
Write open source code
Learn more about category theory, logic, types and how it all fits together
Learn more about design
Redesign this website
Learn economics
Improve health, fitness and earn some sports success

Happy New Year!

SAT in Clojure core.logic

peteris.erins@gmail.com (Peteris Erins) — Fri, 23 Dec 2011 00:00:00 EET

SAT in Clojure core.logic

23.12.2011

After reading a decent portion of On Lisp, I never really wrote an actual macro, until now. This is SAT or boolean satisfiability. I was hoping to write it as a function, but could not figure out if that is possible given that the runs in core.logic are macros.

Code

(defn and-rewrite [expr]
  `(conde
    (~(goalify (second expr))
     ~(goalify (second (rest expr))))))

(defn or-rewrite [expr]
  `(conde
    (~(goalify (second expr)))
    (~(goalify (second (rest expr))))))

(defn demorgan [subexpr]
  (if (and (seq? subexpr)
           (= 'not (first subexpr)))
    (second subexpr)
    (cons 'not (list subexpr))))

(defn not-rewrite [expr]
  (let [expr (second expr)]
    (cond
     (symbol? expr)
     `(== ~expr false)
     (= 'not (first expr))
     (goalify (second expr))
     (= 'and (first expr))
     (goalify (cons 'or  (map demorgan (rest expr))))
     (= 'or (first expr))
     (goalify (cons 'and (map demorgan (rest expr)))))))

(defn goalify [expr]
  "Turns boolean expressions into core.logic goals"
  (cond
   (symbol? expr)
   `(== ~expr true)
   (= 'and (first expr))
    (and-rewrite expr)
   (= 'or (first expr))
    (or-rewrite expr)
   (= 'not (first expr))
    (not-rewrite expr)))

(defmacro sat [vars expr] 
  "SAT"
  `(run* [q#]
         (fresh ~vars
                ~(goalify expr)
                (== q# ~vars))))

Usage

(sat (and p (not p)))
;=> ()

(sat [p q] (not (and (or (not p) q)
                     q)))
;=> ([_.0 false] [true false])

Gitit

peteris.erins@gmail.com (Peteris Erins) — Sun, 18 Dec 2011 00:00:00 EET

Gitit

18.12.2011

Knowing many people who have forgotten the details of much of what they learned in college and school (and the latter includes myself), I’ve been trying to figure out a mechanism for preserving at least the very essential learned thought-processes for concepts in Maths, Computer Science and anything else I end up learning about. Integrating Mendeley into my workflow has been a very fruitful first step. In essence, Mendeley gives fast access to PDFs, supports search, annotations and also synchronizes everything with the cloud. Not to mention it is able to recover a lot of metadata associated with the PDF which is very useful if you are writing papers.

As a second step, I started writing up experimental LaTeX notes for some Maths, but quickly ran out of steam. These are not very rewarding to write, they are not interlinkable, searchable and it is infeasible to write them incrementally. Opening, editing, compiling, previewing, fixing, compiling, closing is a long loop for appending a simple thought.

Gitit is a personal wiki solution that solves these problems and plenty more. It is a git-backed wiki that supports in-browser editing, markdown, latex, code highlighting, slide show creation among other things. Check it out! Naturally, I have set one up as a fluid app. The dog image given on the website was too detailed for the dock, so I created an icon to go with it. I tried to preserve the original color scheme of the disk. The green lambda did’t go well with the disk colors though, so I colored it white. Here is the icon if you need it:

Sliding Window Trick in Python

peteris.erins@gmail.com (Peteris Erins) — Tue, 20 Sep 2011 00:00:00 EEST

Sliding Window Trick in Python

20.09.2011

The Sliding Window Trick is a well-known and widely practiced method in Dynamic Programming that allows you to shave an order of magnitude off of the memory consumption for certain Dynamic Programming algorithms by discarding parts of the table that will not be used in further computation.

Example

Here is a function that returns the r-th row of Pascal’s triangle in Python 2.

def comb_row(r):
    C = [(r + 1) * [0] for _ in range(r + 1)]
    C[0][0] = 1
    for i in range(r + 1):
        C[i][0] = C[i][i] = 1
        for j in range(1, i):
            C[i][j] = C[i - 1][j - 1] + C[i - 1][j]
    return C[r]

A relatively clear implementation, but the memory footprint is quadratic and that might be too much for certain applications.

The Sliding Window approach

Note that we only ever operate on the last two rows in the previous example. Naturally, we can rewrite the function to keep only the last two rows in memory.

def comb_row_sliding(r):
    prev = (r + 1) * [0]
    cur  = (r + 1) * [0]
    prev[0] = 1
    for i in range(r + 1):
        cur[0] = cur[i] = 1
        for j in range(1, i):
            cur[j] = prev[j - 1] + prev[j]
        prev, cur = cur, prev
    return prev

Much better, but that was a lot of work.

The trick

Turns out, we only need to change one line of the first implementation to have it consume only linear memory. It involves a clever use of Python’s list repetition syntax.

def comb_row_neat(r):
    C = [(r + 1) * [0], (r + 1) * [0]] * (r / 2 + 1)
    C[0][0] = 1
    for i in range(r + 1):
        C[i][0] = C[i][i] = 1
        for j in range(1, i):
            C[i][j] = C[i - 1][j - 1] + C[i - 1][j]
    return C[r]

Homework: There is a simpler linear-time, linear-memory, in-place algorithm for the problem that is somewhat harder to spot. I’ll leave it as an exercise.

SICP in Haskell: Chapter 1

peteris.erins@gmail.com (Peteris Erins) — Mon, 22 Aug 2011 00:00:00 EEST

SICP in Haskell: Chapter 1

22.08.2011

I recently (see: Starting SICP in Haskell) started doing the SICP exercises in Haskell. After a more-or-less idle week I’ve managed to finish Section 1.3 and hence Chapter 1. My solutions are at GitHub.

Chapter 1 is called Building Abstractions with Procedures and introduces the basics of programming with a focus on functions including anonymous function and higher-order functions. It was mostly a recap for me, but there were some new things too, e.g., the Miller-Rabin primality test and Simpson’s Rule for integration.

Haskell has been entirely adequate so far. It was probably instructive to have to think about reasonable type signatures for the functions. One mistake I made was trying to use monads for IO initially. Don’t get me wrong, I think monads are great in the long run, but for these kinds of pet problems, solutions with the trace function end up being cleaner and more similar to the respective lisp versions. Also, for similar reasons, I will try to stop generalizing my types so much. It’s tempting and occasionally instructive to make the functions at least as general as the respective lisp versions, but I was overdoing it for this Chapter. Wildcard feature that turned out to be really useful was automatic currying.

Looking forward to the following chapters and hoping it gets a little more challenging. We’ll see how Haskell holds up.

Arrow mania

peteris.erins@gmail.com (Peteris Erins) — Thu, 18 Aug 2011 00:00:00 EEST

Arrow mania

18.08.2011

The Fortress language is a lesser-known programming language currently in development which among other things promises to simplify concurrency via parallelism. It also allows the definition of various operators and complicated precedence rules in ASCII, defining the way code will be presented in LaTeX and how some character combinations would be translated to symbols.

There was an article in the wiki that drew my attention about defining which ASCII sequences should map to every Unicode arrow-like character. It's an amusing article with little applicability for most conventional programming languages. Only a small minority of them define the way their code should be presented, however, a couple do allow the definition of operators or functions of a reasonable set of non-alphanumeric ASCII characters.

This is of use for, e.g, Haskell, Clojure programmers who might want to use the following sensible guidelines if implementing some sort of Mathematical operator that has an adopted arrow symbol. I hope the original author does not mind this article being copied in here. I claim no rights and no ownership. Enjoy the copy below and the gist.

Representing "Arrows" in ASCII

Here is a set of guiding principles for defining ASCII-expressible tokens for arrows and arrow-like things.

Just as we reserved a space of ASCII-expressible tokens to serve for brackets, we can reserve some tokens that would otherwise never occur in practice for arrows. Unfortunately, it's hard to express up and down arrows, but we can do quite well for left and right arrows.

We will just describe right arrows here. Left arrows are obtained by a fairly obvious reversal of characters and using < for >. Bidirectional arrows are made by using two heads rather than a head and a tail.

A right arrow has a right-pointing tail, a body, and a right-pointing head. The body may include a center. At least one of the head, the center, and the tail must be nonempty.

A right-pointing tail consists of some number (possibly zero) of | characters followed by some number (possibly zero) of > characters; among these may be interspersed * characters, but never two * characters in a row, and never a * at the left-hand end.

A body consists of some nonzero number of -, =, and ~ characters. If the body consists of more than two characters, then it may contain a center, provided that there must be at least one body character on each side of the center. (If there is no center, we may simply say that the center is empty.)

A nonempty center consists of some nonzero number of / characters, some nonzero number of | characters, or a single *.

A right-pointing head consists of either (a) some number of |, <, and > characters provided that at least one > is present and that any < must be followed (not necessarily immediately) by a >; or (b) some nonzero number of \ characters or some nonzero number of / characters, followed by some number (possibly zero) of | characters (this case is used for harpoons); or (c) no characters (this case is used for arrow tails and tacks). In either case (a) or case (b), there may be interspersed * characters, but never two * characters in a row, and never a * at the right-hand end. If the head belongs to case (b), then the body must contain at least two characters.

Certain of these are used as Twiki for Unicode arrows. As a rule, we try to make faithful pictures of the arrows, but by convention we use =- for a triple shaft and -=- for a quadruple shaft; |> indicates an open arrowhead, and * indicates blackness.

`->`	→	U+2192 RIGHTWARDS ARROW
`-/->`	↛	U+219B RIGHTWARDS ARROW WITH STROKE
`~>`	↝	U+219D RIGHTWARDS WAVE ARROW
`->>`	↠	U+21A0 RIGHTWARDS TWO HEADED ARROW
`->`	↣	U+21A3 RIGHTWARDS ARROW WITH TAIL
`\|->`	↦	U+21A6 RIGHTWARDS ARROW FROM BAR
`=/=>`	⇏	U+21CF RIGHTWARDS DOUBLE ARROW WITH STROKE
`=>`	⇒	U+21D2 RIGHTWARDS DOUBLE ARROW
`=->`	⇛	U+21DB RIGHTWARDS TRIPLE ARROW
`~~>`	⇝	U+21DD RIGHTWARDS SQUIGGLE ARROW
`->\|`	⇥	U+21E5 RIGHTWARDS ARROW TO BAR
`\|=\|>`	⇨	U+21E8 RIGHTWARDS WHITE ARROW
`\|\|=\|>`	⇰	U+21F0 RIGHTWARDS WHITE ARROW FROM WALL
`-\|->`	⇸	U+21F8 RIGHTWARDS ARROW WITH VERTICAL STROKE
`-\|\|->`	⇻	U+21FB RIGHTWARDS ARROW WITH DOUBLE VERTICAL STROKE
`-\|>`	⇾	U+21FE RIGHTWARDS OPEN-HEADED ARROW
`-->`	➔	U+2794 HEAVY WIDE-HEADED RIGHTWARDS ARROW
`=->`	➙	U+2799 HEAVY RIGHTWARDS ARROW
`--*>`	➛	U+279B DRAFTING POINT RIGHTWARDS ARROW
`==>`	➜	U+279C HEAVY ROUND-TIPPED RIGHTWARDS ARROW
`-\|*>`	➝	U+279D TRIANGLE-HEADED RIGHTWARDS ARROW
`--\|>`	➞	U+279E HEAVY TRIANGLE-HEADED RIGHTWARDS ARROW
`==\|>`	➡	U+27A1 BLACK RIGHTWARDS ARROW
`\|==*>`	➧	U+27A7 SQUAT BLACK RIGHTWARDS ARROW
`\|=\|>*>`	➩	U+27A9 RIGHT-SHADED WHITE RIGHTWARDS ARROW
`\|*=\|>`	➪	U+27AA LEFT-SHADED WHITE RIGHTWARDS ARROW
`->`	➳	U+27B3 WHITE-FEATHERED RIGHTWARDS ARROW
`*>->`	➵	U+27B5 BLACK-FEATHERED RIGHTWARDS ARROW
`>->`	➸	U+27B8 HEAVY BLACK-FEATHERED RIGHTWARDS ARROW
`>-\|>`	➼	U+27BC WEDGE-TAILED RIGHTWARDS ARROW
`>>-\|*>`	➽	U+27BD HEAVY WEDGE-TAILED RIGHTWARDS ARROW
`-->`	⟶	U+27F6 LONG RIGHTWARDS ARROW
`==>`	⟹	U+27F9 LONG RIGHTWARDS DOUBLE ARROW
`\|-->`	⟼	U+27FC LONG RIGHTWARDS ARROW FROM BAR
`\|==>`	⟾	U+27FE LONG RIGHTWARDS DOUBLE ARROW FROM BAR
`~~~>`	⟿	U+27FF LONG RIGHTWARDS SQUIGGLE ARROW
`-\|->>`	⤀	U+2900 RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE
`-\|\|->>`	⤁	U+2901 RIGHTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE
`=\|=>`	⤃	U+2903 RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE
`\|->>`	⤅	U+2905 RIGHTWARDS TWO-HEADED ARROW FROM BAR
`\|=>`	⤇	U+2907 RIGHTWARDS DOUBLE ARROW FROM BAR
`-\|->`	⤔	U+2914 RIGHTWARDS ARROW WITH TAIL WITH VERTICAL STROKE
`-\|\|->`	⤕	U+2915 RIGHTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE
`->>`	⤖	U+2916 RIGHTWARDS TWO-HEADED ARROW WITH TAIL
`-\|->>`	⤗	U+2917 RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE
`-\|\|->>`	⤘	U+2918 RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE
`--`	⤚	U+291A RIGHTWARDS ARROW-TAIL
`--`	⤜	U+291C RIGHTWARDS DOUBLE ARROW-TAIL
`-><*>`	⤞	U+291E RIGHTWARDS ARROW TO BLACK DIAMOND
`\|-><*>`	⤠	U+2920 RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND
`~->`	⤳	U+2933 WAVE ARROW POINTING DIRECTLY RIGHT
`-=->`	⭆	U+2B46 RIGHTWARDS QUADRUPLE ARROW

`<-`	←	U+2190 LEFTWARDS ARROW
`<-/-`	↚	U+219A LEFTWARDS ARROW WITH STROKE
`<~`	↜	U+219C LEFTWARDS WAVE ARROW
`<<-`	↞	U+219E LEFTWARDS TWO HEADED ARROW
`<-<`	↢	U+21A2 LEFTWARDS ARROW WITH TAIL
`<-\|`	↤	U+21A4 LEFTWARDS ARROW FROM BAR
`<=/=`	⇍	U+21CD LEFTWARDS DOUBLE ARROW WITH STROKE
`<=`	⇐	U+21D0 LEFTWARDS DOUBLE ARROW
`<-=`	⇚	U+21DA LEFTWARDS TRIPLE ARROW
`<~~`	⇜	U+21DC LEFTWARDS SQUIGGLE ARROW
`\|<-`	⇤	U+21E4 LEFTWARDS ARROW TO BAR
`<\|=\|`	⇦	U+21E6 LEFTWARDS WHITE ARROW
`<-\|-`	⇷	U+21F7 LEFTWARDS ARROW WITH VERTICAL STROKE
`<-\|\|-`	⇺	U+21FA LEFTWARDS ARROW WITH DOUBLE VERTICAL STROKE
`<\|-`	⇽	U+21FD LEFTWARDS OPEN-HEADED ARROW
`<--`	⟵	U+27F5 LONG LEFTWARDS ARROW
`<==`	⟸	U+27F8 LONG LEFTWARDS DOUBLE ARROW
`<--\|`	⟻	U+27FB LONG LEFTWARDS ARROW FROM BAR
`<==\|`	⟽	U+27FD LONG LEFTWARDS DOUBLE ARROW FROM BAR
`<=\|=`	⤂	U+2902 LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE
`\|=>`	⤆	U+2906 LEFTWARDS DOUBLE ARROW FROM BAR
`--<`	⤙	U+2919 LEFTWARDS ARROW-TAIL
`--<<`	⤛	U+291B LEFTWARDS DOUBLE ARROW-TAIL
`<*><-`	⤝	U+291D LEFTWARDS ARROW TO BLACK DIAMOND
`<*><-\|`	⤟	U+291F LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND
`<\|==`	⬅	U+2B05 LEFTWARDS BLACK ARROW
`<~~~`	⬳	U+2B33 LONG LEFTWARDS SQUIGGLE ARROW
`<<-\|-`	⬴	U+2B34 LEFTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE
`<<-\|\|-`	⬵	U+2B35 LEFTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE
`<<-\|`	⬶	U+2B36 LEFTWARDS TWO-HEADED ARROW FROM BAR
`<-\|-<`	⬹	U+2B39 LEFTWARDS ARROW WITH TAIL WITH VERTICAL STROKE
`<-\|\|-<`	⬺	U+2B3A LEFTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE
`<<-<`	⬻	U+2B3B LEFTWARDS TWO-HEADED ARROW WITH TAIL
`<<-\|-<`	⬼	U+2B3C LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE
`<<-\|\|-<`	⬽	U+2B3D LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE
`<-~`	⬿	U+2B3F WAVE ARROW POINTING DIRECTLY LEFT
`<-=-`	⭅	U+2B45 LEFTWARDS QUADRUPLE ARROW

`<->`	↔	U+2194 LEFT RIGHT ARROW
`<~>`	↭	U+21AD LEFT RIGHT WAVE ARROW
`<-/->`	↮	U+21AE LEFT RIGHT ARROW WITH STROKE
`<=/=>`	⇎	U+21CE LEFT RIGHT DOUBLE ARROW WITH STROKE
`<=>`	⇔	U+21D4 LEFT RIGHT DOUBLE ARROW
`<-\|->`	⇹	U+21F9 LEFT RIGHT ARROW WITH VERTICAL STROKE
`<-\|\|->`	⇼	U+21FC LEFT RIGHT ARROW WITH DOUBLE VERTICAL STROKE
`<\|-\|>`	⇿	U+21FF LEFT RIGHT OPEN-HEADED ARROW
`<-->`	⟷	U+27F7 LONG LEFT RIGHT ARROW
`<==>`	⟺	U+27FA LONG LEFT RIGHT DOUBLE ARROW
`<=\|=>`	⤄	U+2904 LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE
`<\|=\|>`	⬄	U+2B04 LEFT RIGHT WHITE ARROW
`<\|==\|*>`	⬌	U+2B0C LEFT RIGHT BLACK ARROW

`--\`	⇀	U+21C0 RIGHTWARDS HARPOON WITH BARB UPWARDS
`--/`	⇁	U+21C1 RIGHTWARDS HARPOON WITH BARB DOWNWARDS
`--\\|`	⥓	U+2953 RIGHTWARDS HARPOON WITH BARB UP TO BAR
`--/\|`	⥗	U+2957 RIGHTWARDS HARPOON WITH BARB DOWN TO BAR
`\|--\`	⥛	U+295B RIGHTWARDS HARPOON WITH BARB UP FROM BAR
`\|--/`	⥟	U+295F RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR

`/--`	↼	U+21BC LEFTWARDS HARPOON WITH BARB UPWARDS
`\--`	↽	U+21BD LEFTWARDS HARPOON WITH BARB DOWNWARDS
`\|/--`	⥒	U+2952 LEFTWARDS HARPOON WITH BARB UP TO BAR
`\|\--`	⥖	U+2956 LEFTWARDS HARPOON WITH BARB DOWN TO BAR
`/--\|`	⥚	U+295A LEFTWARDS HARPOON WITH BARB UP FROM BAR
`\--\|`	⥞	U+295E LEFTWARDS HARPOON WITH BARB DOWN FROM BAR

`/==/`	⇋	U+21CB LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
`\==\`	⇌	U+21CC RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
`/--/`	⥊	U+294A LEFT BARB UP RIGHT BARB DOWN HARPOON
`\--\`	⥋	U+294B LEFT BARB DOWN RIGHT BARB UP HARPOON
`/--\`	⥎	U+294E LEFT BARB UP RIGHT BARB UP HARPOON
`\--/`	⥐	U+2950 LEFT BARB DOWN RIGHT BARB DOWN HARPOON

`\|--`	⊢	U+22A2 RIGHT TACK
`\|-`	⊦	U+22A6 ASSERTION
`\|=`	⊧	U+22A7 MODELS
`\|==`	⊨	U+22A8 TRUE
`\|\|--`	⊩	U+22A9 FORCES
`\|\|\|-`	⊪	U+22AA TRIPLE VERTICAL BAR RIGHT TURNSTILE
`\|\|==`	⊫	U+22AB DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
`\|-/-`	⊬	U+22AC DOES NOT PROVE
`\|=/=`	⊭	U+22AD NOT TRUE
`\|\|-/-`	⊮	U+22AE DOES NOT FORCE
`\|\|=/=`	⊯	U+22AF NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
`\|---`	⟝	U+27DD LONG RIGHT TACK

`--\|`	⊣	U+22A3 LEFT TACK
`---\|`	⟞	U+27DE LONG LEFT TACK
`-\|`	⫞	U+2ADE SHORT LEFT TACK
`--\|\|`	⫣	U+2AE3 DOUBLE VERTICAL BAR LEFT TURNSTILE
`==\|`	⫤	U+2AE4 VERTICAL BAR DOUBLE LEFT TURNSTILE
`==\|\|`	⫥	U+2AE5 DOUBLE VERTICAL BAR DOUBLE LEFT TURNSTILE

`-\|\|-`	⟛	U+27DB LEFT AND RIGHT TACK
`=\|\|=`	⟚	U+27DA LEFT AND RIGHT DOUBLE TURNSTILE

Note that, under these rules, the ASCII token =/= for "not equals" is considered an "arrow", not that it really matters. The other two cases of interest that have empty head and empty tail are -||- for ⟛ U+27DB LEFT AND RIGHT TACK and =||= for U+27DA LEFT AND RIGHT DOUBLE TURNSTILE.

Introducing jacobian

peteris.erins@gmail.com (Peteris Erins) — Sun, 14 Aug 2011 00:00:00 EEST

Introducing jacobian

14.08.2011

We Contract Bridge players have never been blessed with good software. Chess players have it all: protocols, GUIs, engines. Many of them free. In Bridge, we have a collection of all-in-one packages, ranging from expensive to unusable. The only means of communication among them are online bridge servers and a protocol used solely at the World Computer Bridge Championships that requires programs to talk over TCP/IP.

This is not only a barrier of entry in the computer bridge arena, but also is a missed opportunity in terms of getting more people involved in the game and increasing the overall level of play. Just look at how fast the Free Robot Bridge tournaments fill up at BridgeBase Online and it will be clear that there is significant demand for usable and free bridge robots.

A little while ago Edgars Sedols and I decided to do something about this. What we wanted was not a revolution in the computer bridge industry but the simple ability to set a deal and declare it against two robots. So we created jacobian.

Jacobian is a simple, incomplete, but working protocol for computer bridge programs. With the host program, you specify a deal, vulnerability, contract and the four players by specifying their executable programs. The host then leads them trough a game of bridge (currently, only the play of the hand is implemented). That’s it.

The “players” can be anything as long as they adhere to the protocol. A GUI can be a player, serving as an interface to the protocol for a human player. A robot can be a player in which case the program will be a wrapper for the robot implementing the jacobian protocol.

We wrote everything in Java due to its popularity and cross-platform support. Ironically, the current version is Unix only, but we’re working on that already. The protocol description and the host program can be located at jacobian-host. The GUI can be found at jacobian-GUI. A GiB engine wrapper is at jacobian-gib-wrapper. You will need your own GiB engine to play though.

The whole package is really rough around the edges at the moment. To get started with it, if you’re on a Unix computer, you will need to fetch the three .jar files first. Put them in the same folder together with your GiB engine. Rename the GiB engine to gib.exe if it’s named bridge.exe (we are using the free version for our experiments). You can test-drive a hand by writing

$ java -jar jacobian-host.jar 'java -jar jacobian-gib-wrapper.jar' 'java -jar jacobian-gib-wrapper.jar' 'java -jar jacobian-gui.jar' 'java -jar jacobian-gib-wrapper.jar' 3031333123220300123320212213021202022103101101003113 NONE 3NS

We have scratched our itch, we can now play a hand with GiB. But we would be happy to continue working with the community on this if we see some support and potential. You are absolutely welcome to contribute and/or implement the protocol for your own applications and make the Bridge world a little bit more open for everyone.

Starting SICP in Haskell

peteris.erins@gmail.com (Peteris Erins) — Fri, 12 Aug 2011 00:00:00 EEST

Starting SICP in Haskell

12.08.2011

Let me introduce the uninformed reader to Structure and Interpretation of Computer Programs. It is a (free) book and a course originally introduced in MIT as an introductory series in Computer Science. Despite the fact that the first edition of the book dates back to 1985 (!) and that it uses Lisp (Scheme) as the main programming language, the book sustains a small but strong fellowship to this day. Why? Antti Sykari describes on Stack Overflow:

“It is a book that will enlighten you. It will evoke in you a passion for writing beautiful programs. Moreover, it will teach you to recognize and appreciate that very beauty. It will leave you with a state of awe and an unquenchable thirst to learn more. Other books may make you a better programmer; this book will make you a programmer.”

So I’ve decided to read it and do the exercises. Not expecting to be blown away by the book as I’ve had some prolonged exposure to algorithms and functional programming before, but why not fill up the holes in my knowledge and compensate for the lack of a proper CS degree?

The fun thing is that I will be doing it in Haskell. I’ve picked up more Lisp than would be fair before starting this book and instead decided to do it in a language I would be learning while reading. Haskell is appropriate, being a functional language, but with its static type system, pervasive laziness and purity, it will hopefully provide enough of a challenge. You can follow along at the dedicated GitHub repository. Now this is lower priority than work, studies and personal projects, but I expect to put up something every week. I wouldn’t want to end up owning one of the many unfinished SICP repositories in GitHub.

P.S. Fun fact about Lisp. A couple of years ago I had the preconception that Lisp was useful primarily for list processing (hence the name) and would be an overly specific language to learn and use. I really only knew C++ and as it later turned out was embarrassingly conservative. Now I’ve played around with a couple of more languages including ironically a fresh dialect of Lisp called Clojure. My idea of Lisp has been upraised to the extent that I wonder if that name was appropriate to begin with.

Google+, a New Blogging Platform in Town?

peteris.erins@gmail.com (Peteris Erins) — Sun, 03 Jul 2011 00:00:00 EEST

Google+, a New Blogging Platform in Town?

03.07.2011

There have been a couple of interesting posts recently about how Google+ (G+) could be a threat to Facebook, Twitter, LinkedIn and Skype among others. I think there is significant inertia in these platforms in terms of their established and reasonably happy userbases, if only because these users themselves were not acquired in a year or two. However, G+ does have long term features going for it, such as Google integration and the ability to adapt to various use cases.

Apart from the early-adopters, the first real chunks of users might come from niche features done right. An obvious example is videoconferencing. The G+ team has done an amazing job with Hangouts and people (and businesses?) will find this extremely convenient.

Another case I see for it is blogging. G+ makes it really easy to share your thoughts. There is clearly enough technology in there to satisfy most bloggers’ needs. You also get immediate exposure, integrated comments and best of all, sharing your content is a click of a button away.

Can we use it today? To a certain extent, yes, and in fact you could consider anyone who is writing longish pieces of writing in G+ to be using it as a blogging platform. We do have to wait a bit more to see how Google will handle the publicity of your posts. Ideally, you would like them to be visible to people who are not using G+ in a nice way. Another issue is lack of styling options. There is a conflict with Google’s accessibility standards and most likely you will not be able to enforce a particular style to your writing.

That said, most people using, e.g., posterous use the same template, and G+ might well end up eliminating the need to choose a blogging platform.

Free ePub and mobi books for programmers

peteris.erins@gmail.com (Peteris Erins) — Fri, 24 Jun 2011 00:00:00 EEST

Free ePub and mobi books for programmers

24.06.2011

If you use an eReader, I’m sure you know the difference between a PDF and ePub/mobi book. In the case of the Kindle, for the latter, you can change the font and its size, look up words in the dictionary and even have the Kindle read the book out loud to you. For a PDF, you are normally forced to resort to landscape to get a reasonable text size and to not have to use the cumbersome zoom feature.

There are plenty free eBooks about programming in PDF and/or HTML. The latter can easily be ported to the eReader formats and some people have indeed been doing that. Here I’ve tried to list the free ePub mobi programming books that I’ve found on the web (mainly in GitHub). Note that most eReaders do not support both formats, but that usually isn’t a problem, because you can use software like Calibre to convert between the two. Credit goes to authors and porters. Happy reading!

And if you know of some more, please add them in the comments!

How To: Compile every language from Vim

peteris.erins@gmail.com (Peteris Erins) — Tue, 21 Jun 2011 00:00:00 EEST

How To: Compile every language from Vim

21.06.2011

Warning: This post is for users of the Vim text editor. It might not be relevant to you unless you have been using it already or want a compelling argument to start doing so.

One of the many reasons I like Vim is how easy it is to set up a workable environment for any programming language. For most popular languages, filetype recognition and syntax highlighting are already in there. What I like to do further, is to set up easy compilation and running from within Vim with the click of a button. This post will show how.

We are concerned with single source files, useful for when you are starting out in a new language, doing programming competitions or merely experimenting with language features, and want a little more control than you can get with a REPL.

Setting up C compilation

We are going to start with gcc and C compilation (a sufficiently non-trivial example), but we will look at a few others in the end. To compile a file test.c with gcc into test.out, we write

$ gcc -o test.out test.c

When editing a file in Vim, you can run a command for the native terminal by preceding it with :!. For example, in Unix, try writing

:!ls

So, if we know that our filename is test.c, we can now compile and run without resorting to an external terminal window

:!gcc -o test.out test.c && ./test.out

Note we were assuming that the current directory is the directory of the file we are editing, which is not always the case. This will not be a problem as we generalize.

Now, this is already quite convenient, but what if we had longer filenames? Turns out, there is a shortcut for getting the filename, it’s ”%”. Back to Vim:

:!gcc -o ?? "%" && ??

”%” will expand into “test.c”, but how can we get test.out? We need Vim’s filename modifiers. :p gives us the full path and :r removes the extension. So what we need is

:!gcc -o "%:p:r.out" "%:p" && "%:p:r.out"

This would work for every file, all that’s left now is to put it in .vimrc. I like to map it to F9 like so:

autocmd FileType c map <F9> :!gcc --o "%:p:r.out" "%:p" && "%:p:r.out"<CR>

And we’re good to go! Restart Vim and hit F9 while editing a C file to see it happen.

Other languages

Java classes present us with new kinds of issues, but they still fall to Vim’s file modifiers. We use :h to get the classpath and :t helps us get the class name by stripping the path away.

autocmd FileType java map <F9> :!javac "%:p" && java -cp "%:p:h" "%:t:r"<CR>

Interpreted languages are even easier, here’s ruby:

autocmd FileType ruby map <F9> :!ruby "%:p"<CR>

Further tips

If you want to separate compilation and execution, that’s easy too. I’ve also added a “| more” to make sure the first error does not leave the screen.

autocmd FileType c map <F6> :!gcc --o "%:p:r.out" "%:p" <bar> more<CR>
autocmd FileType c map <F7> :!"%:p:r.out"<CR>

Documentation

Although :p, :r, :h and :t should be sufficient for most cases, there is much more you can do with file modifiers. Hit up

:!help filename-modifiers

To find out more.

How this site was built

peteris.erins@gmail.com (Peteris Erins) — Sat, 18 Jun 2011 00:00:00 EEST

How this site was built

18.06.2011

Let me begin by elaborating on the construction of this website. Instead of spraying a cloud of creepy sounding buzzwords, I’ll try and start from the requirements and show why these choices were a good fit in my scenario. It might be helpful to look at the source code as you’re reading this. I am not planning to go through the meaning of every file, there are many good tutorials on all technologies involved, so please check them out if you’re interested in the details.

What does one want in a blog?

There are a couple of little things that matter. A good blog environment would

allow me to focus on creating content (posts). It would take care of interface and style issues and render my site for viewing on all popular platforms.
It would support simple but important dynamic tasks, such as listing a certain number of recent posts, extracting dates and titles, allowing users to comment on the website, etc.
It should be easy to debug.

HTML5 boilerplate

This was a natural starting point for a project using HTML and CSS. It has all the standard practices baked in. HTML5 boilerplate provides you with

an appropriate directory structure;
basic .html, .css and .js files filled out with cross-platform compatibility boilerplate, resets and libraries;
build script for minification and other useful automated tasks;
most importantly, many other things I am not and do not have to be aware of thanks to the boilerplate team.

Jekyll

Quite a few people already have advertised Jekyll to a more than adequate extent. It is essentially a preprocessor that has built-in support for blog posts. I feed in content written in plain-text (more precisely, markdown), some layout files serving as templates for, e.g., posts, and it spits out a blog in HTML. Yes, no databases, server-side scripting or admin panels. Best part: you get a working idea of what’s going on without having to dive into the source code.

Putting it all together

To combine the two, I wanted something that spits out a blog that would have all the best practices, minified code and whatnot.

To the credit of these technologies, joining them is easy if you are familiar with both. I run Jekyll first to generate the html for posts and the main page, putting the end-product in the _sites folder. Then, the build script is run on the assembled website. It is cleaned up for publishing and is ready for deployment at _sites/publish.

The only non-trivial part was making the build script aware of all the posts so that it can work on their HTML. The solution is to have the build config (called project.properties) as a Jekyll template file and write the following line:

file.pages =
{% for post in site.posts  %}
  {{ post.url | replace_first: '/', ''  }},
{% endfor %}index.html, 404.html,

It merely loops over all the posts and inserts their URLs into the build script, comma-separated.

The result

Writing blog posts becomes as easy and rewarding as drinking liquid.

Hello World!

peteris.erins@gmail.com (Peteris Erins) — Thu, 16 Jun 2011 00:00:00 EEST

Hello World!

16.06.2011

After two days of hard work, apparently there was something worth publishing, so here we are.

I have wanted to have a blog for a long time. After lots of reading and playing around with Wordpress and posterous to no satisfaction, I eventually stumbled upon Jekyll and was instantly sold. For a small personal blog, it offers a good mix of flexibility and simplicity. It is lightweight, easy to pick up and secure, features that are scarce nowadays. If you haven’t, by all means try it out, it is the one thing that made this blog a reality.

As far as the direction of this blog, I have no clue at the moment. Expect a healthy dose of math and code as well as some ad hoc material once in a while. We’ll see.

As I’m writing this, I realize that there is nothing apart from the “up” link to signify the end of a post. I should probably think of something more meaningful.