Gerhard Häring

Vocabulary trainer in Clojure

noreply@blogger.com (Gerhard Häring) — Tue, 03 Jan 2012 00:16:00 +0000

~/src/gh/voc/train.clj.html

(use '[clojure.string :only (split split-lines)])

; file is tab-seperated pairs of foreign and native words

(let [contents (slurp "100a.txt" :encoding "utf-8")
      lines (split-lines contents)
      pairs (map #(split % #"\t") lines)]

  (loop [my-pairs (shuffle pairs)]
    (let [pair (first my-pairs)]
      (do
        (println)
        (println (first (first my-pairs)))
        (if (not= (read-line) (second pair))
          (do
            (println "wrong, correct is:" (second pair))
            (recur (shuffle my-pairs)))
          (do
            (println "correct")
            (if (seq (rest my-pairs)) ; (seq idiomatic for (not (empty?
              (recur (rest my-pairs)))))))))

Monty Hall problem in Clojure

noreply@blogger.com (Gerhard Häring) — Mon, 02 Jan 2012 10:44:00 +0000

~/src/gh/goat.clj.html

; Monty Hall problem in Clojure

(defn pick-first-guess [doors]
  (first doors)
)

(defn change-guess [doors]
  (if (= :goat (second doors)) (last doors)
    (second doors))
)

(def samples (map shuffle (repeat 1000 [:goat :goat :car])))

(count (filter #(= % :car) (map pick-first-guess samples)))
(count (filter #(= % :car) (map change-guess samples)))

Twitter Spelling Test

noreply@blogger.com (Gerhard Häring) — Tue, 31 Aug 2010 11:24:00 +0000

Created by Oatmeal

Youtube down

noreply@blogger.com (Gerhard Häring) — Thu, 25 Mar 2010 11:34:00 +0000

I've seen that for the first time in years.

Experimenting with Scala

noreply@blogger.com (Gerhard Häring) — Thu, 18 Mar 2010 09:31:00 +0000

This is my first useful Scala program. It was ported from a Python program (see below). In 1993 I wrote an equivalent in Modula-2 ;-)

import scala.io.Source;
import java.io.File;
import scala.util.Random;

object voc {
  def train(lst : List[Tuple2[String, String]]) : Unit = {
    println();
    if (lst.length == 0) {
      println(":-D");
      return;
    }

    val shuffled = Random.shuffle(lst);
    val current = shuffled.head;
    println(">>> " + current._1);
    var line = Console.readLine();
    if (line == current._2) {
      println("correct");
      train(shuffled.tail);
    } else {
      print("\007");
      println("wrong - correct is: " + current._2);
      train(shuffled);
    }
  }

  def main(args: Array[String]) {
    val lst = Source.fromFile(new File(args(0))).getLines()
          .map { s => s.split("\t") }
          .filter( l => l.length == 2 )
          .map (l => Tuple2(l.head, l.last))
          .toList;

    train(lst);
  }
}

Python version:

from __future__ import with_statement
import random
import sys

def train(lst):
    while len(lst) > 0:
        random.shuffle(lst)

        lang1, lang2 = lst[0]

        print ">>>", lang1
        try:
            answer = raw_input("answer: ").strip()
        except EOFError:
            # ^Z pressed, ignore
            continue

        if answer == lang2:
            print "correct"
            lst = lst[1:]
        else:
            print chr(7)
            print "wrong - correct is =>", lang2

        print
        print

    print ":-D"

def main():
    filename = sys.argv[1]

    lst = []
    for line in open(filename):
        line = line.strip()
        if not line:
            continue
        parts = line.split("\t")
        assert len(parts) == 2
        lst.append(parts)

    train(lst)


if __name__ == "__main__":
    main()

PHP, the forgotten programming language

noreply@blogger.com (Gerhard Häring) — Sun, 14 Mar 2010 16:24:00 +0000

I just took a quiz and had a complete blackout of PHP. Can you name the 25 most popular programming languages? Quiz here.

Olympic Winter Games

noreply@blogger.com (Gerhard Häring) — Wed, 17 Feb 2010 16:16:00 +0000

How little do you care?

Vote at SPON.

Schreiber vs. Brüderle

noreply@blogger.com (Gerhard Häring) — Mon, 18 Jan 2010 16:39:00 +0000

Interesting read about unit tests

noreply@blogger.com (Gerhard Häring) — Thu, 05 Nov 2009 00:15:00 +0000

It's OK Not to Write Unit Tests is an interesting blog post. Recommended to make you think again why you write them, if what you're writing are really unit tests, etc.

Unverständnis bei Bosbach von CDU

noreply@blogger.com (Gerhard Häring) — Mon, 05 Oct 2009 11:06:00 +0000

"Ich verstehe die Kritik der Liberalen an den auf Kinderpornografie beschränkten Netzsperren nicht." Es gebe kein Recht auf ungehinderten Zugriff auf Kinderpornografie im Internet, betonte Bosbach.

Netzwelt-Ticker: Google Wave strandet an der Hypeküste - SPIEGEL ONLINE - Nachrichten - Netzwelt

Liberale wollen im Internet weiter freien Zugriff auf KiPo haben, während die CDU das Netz für uns sicher machen will. So einfach ist das-

2009-01-07: Creating self-signed certificates

noreply@blogger.com (Gerhard Häring) — Tue, 16 Jun 2009 08:09:00 +0000

Note to self: When my self-signed certificate for my mail server expires next year at about the same time, this should fix it:

openssl req -config /etc/ssl/openssl.cnf \
-new -x509 -nodes -out /etc/ssl/certs/dovecot.pem \
-keyout /etc/ssl/private/dovecot.pem

The really hard bugs ...

noreply@blogger.com (Gerhard Häring) — Mon, 18 Jul 2005 11:52:00 +0000

D. Richard Hipp today on the SQLite mailing list:

I am constantly amazed at the prevailing idea (exemplified
by Java) that software should be strongly typed and should
not use goto statement or pointers - all in the name of
reducing bugs - but that it is OK to use multiple threads
within the same address space. Strong typing helps prevent
only bugs that are trivially easy to locate and fix. The
use of goto statements and pointers likewise results in
deterministic problems that are easy to test for and
relatively easy to track down and correct. But threading
bugs tend to manifest themselves as timing-dependent
glitches and lock-ups that are hardware and platform
dependent, that never happen the same way twice, and that
only appear for customers after deployment and never in a
testing environment.