There is a monster under my keyboard

Hello World!

This is my, as of yet, handcoded Blog. I am starting it for two reasons:

• I need more practice writing, especially because English is not my first language. So, corrections are welcome. (Hmm, a comment feature could be useful...)
• It will force me to get my side projects into a presentable state and give me a place to catalogue them.

The main topics of this blog are programming languages and the cool things you can do with them. So expect some posts about fractals, Haskell and BrainF*ck. I enjoy doing programming puzzles, so there may be something about Project Euler or the like, too. The language I am most proficient in is Java but I'll try to do as much as possible in other languages, especially non-Object Oriented ones. Simply because doing new things is more interesting than repeating old things. (Doesn't stop me from implementing a Mandelbrot viewer every year...)

At the moment, the second most important thing is getting syntax highlighting to work. Bear with me for a moment. *Elevator music*

public static void fizzBuzz(int n)
{
	for(int i = 1; i <= n; i++)
	{
		String out = "";
		if(i % 3 == 0)
			out += "Fizz";
		if(i % 5 == 0)
			out += "Buzz";
		if(out.length() > 0)
			System.out.println(out);
		else
			System.out.println(i);
	}
}

Feeling right at home. I like having some curly braces from time to time. Please note: it's not important if you and I have different bracing and indentation styles as long as we are not mixing them in the same project.

fib n = go n 0 1
    where go 0 a _ = a
          go n a b = go (n - 1) b (a + b)

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

phi = 1 : map ((1+) . (1/)) phi

Sorry, I couldn't resist the temptation of writing my 144th or 233rd (not sure) implementation of the Fibonacci Numbers. The other two are lazy lists of Fibonacci Numbers and numbers converging to Φ (Phi), the Golden Ratio.

(use '[clojure.contrib.math :only [abs]])

; Lazy sequence of the numbers 1, -1/3, 1/5, -1/7, 1/9...
(def fracts
  (map
    #(double 
      (/ (if (even? %) 1 -1)
         (inc (* 2 %))))
    (range)))

; n-th element of 'approxs' is the sum of the first n elements in 'fracts' times 4
; For big n, this sum approaches Pi
(def approxs
  (map #(* 4 %)
    (reductions + fracts)))

(defn pi "Compute an approximation of Pi with an error of at most 'eps'" [eps]
  (loop [[fst snd & rest] approxs]
    (if (< (abs (- fst snd)) eps)
        fst
        (recur (cons snd rest)))))

I should warn you: I know Lisp and am willing to use it. (Lazy sequences too.) Hopefully the comments explain the intent of this code snippet.

Looks like syntax highlighting is working nicely. Now we're getting to our last code snippet. Can you guess the language? Or the output?

++++++++
[
	>++++++++
	>++++++++++++
	>++++
	<<<-
]
>++++++++.
>+++++.+++++++..+++.
>.
<<+++++++++++++++.
>.+++.------.--------.
>+.

Aaand, we're done. I'll probably come back to this nice and simple language very soon, because I think it makes for some nice puzzles. Also because writing an interpreter or compiler is so easy and tempting.

So, syntax highlighting was the second most important thing. The Most Important and hardest thing is publishing all this and keeping on writing it.
Let's do this.