try { } catch blog

ErlyMock 3.0.0 Created!

2011-02-19T01:53:00.000+01:00

New Erlymock Release

2011-02-06T07:43:00.001+01:00

The project has evolved and can be found here: ErlyMock

Age

2010-11-07T19:12:00.002+01:00

Sadly, I will never be as young as I am right now. Luckily, I will neither be any older than I am in the present moment.

My minimalistic xinitrc, xmonad.hs and xmobarrc

2010-08-01T16:41:00.017+02:00

put this in ~/.xinitrc

ck-launch-session

# start trayer to contain apps like nm-applet

trayer --edge top --align right --SetDockType true --SetPartialStrut true --expand true --width 5 --transparent true --tint 0x191970 --height 12 &

kmix &

# some cool effects

xcompmgr -c -f -F &

# Set the background color

hsetroot -tile /home/sven/Wallpapers/abstract-bluelights-1280x800-.jpg

xset b 100 0 0

xset r rate 190 90

dbus-launch --exit-with-session xmonad

put this in ~/.xmonad/xmonad.hs

import XMonad

import qualified XMonad.StackSet as W

import XMonad.ManageHook

import XMonad.Hooks.ManageHelpers

import XMonad.Hooks.DynamicLog

import XMonad.Hooks.ManageDocks

import XMonad.Hooks.FadeInactive()

import XMonad.Hooks.SetWMName(setWMName)

import XMonad.Layout.NoBorders(smartBorders)

import XMonad.Layout.Tabbed(tabbed, shrinkText, defaultTheme)

import XMonad.Layout.LayoutHints(layoutHints)

import XMonad.Layout.LayoutModifier

import XMonad.Util.Run(spawnPipe)

import XMonad.Util.EZConfig(additionalKeys)

import System.IO



import XMonad.Prompt(defaultXPConfig, autoComplete, XPPosition(Bottom), position)

import XMonad.Prompt.RunOrRaise(runOrRaisePrompt)

import XMonad.Actions.WindowGo(runOrRaiseNext)

import XMonad.Actions.UpdatePointer()

import XMonad.Prompt.Man(manPrompt)

import XMonad.Prompt.Window(windowPromptGoto)

import XMonad.Util.Themes()



main = do

  mobar <- spawnPipe "/usr/bin/xmobar ~/.xmonad/xmobarrc" 

  xmonad $ defaultConfig { manageHook = manageDocks <+> customManageHooks <+> manageHook defaultConfig

                         , layoutHook = avoidStruts sheyllLayouts

                         , modMask = windowsKey -- rebind ALT modifier key to WIN

                         , logHook = myLogHook mobar

                         , terminal = "konsole"

                         , startupHook = setWMName "LG3D"

                         } `additionalKeys` sheyllShortCuts

      where myLogHook mobar = dynamicLogWithPP sjanssenPP  { ppOutput = hPutStrLn mobar

                                                     }       



customManageHooks = composeAll [ className =? "ioUrbanTerror" --> doFullFloat

                               , className =? "XConsole"      --> doFloat

                               , className =? "Kcalc"         --> doFloat

                               , className =? "Pidgin"        --> doFloat

                               , className =? "Kmix"          --> doFloat]



windowsKey = mod4Mask



sheyllLayouts = smartBorders $ 

                 tabbed shrinkText defaultTheme

                ||| layoutHints (layoutHook defaultConfig)



sheyllShortCuts = [ ((windowsKey, xK_p), runOrRaisePrompt defaultXPConfig

                                           { position = Bottom

                                           , autoComplete = Just 500000 })

                  -- important apps

                  , ((windowsKey, xK_Return), runOrRaiseNext "konsole"

                                           (className =? "Konsole"))

                  , ((windowsKey, xK_f), runOrRaiseNext "google-chrome"

                                           (className =? "Google-chrome"))

                  , ((windowsKey .|. shiftMask, xK_f), spawn "google-chrome")

                    

                  , ((windowsKey, xK_a), runOrRaiseNext "emacs" (className =?

                                                                     "Emacs"))

                  , ((windowsKey .|. shiftMask, xK_a), spawn "emacs")

                    

                  , ((windowsKey, xK_d), runOrRaiseNext "dolphin" (className

                                                                                     =? "Dolphin"))

                  , ((windowsKey .|. shiftMask, xK_d), spawn "dolphin")

                    

                  , ((windowsKey, xK_End), kill)

                    

                  -- eclipse IDE

                  , ((windowsKey, xK_x), runOrRaiseNext "eclipse" (className =?

                                                                     "Eclipse"))

                  , ((windowsKey .|. shiftMask, xK_x), spawn "eclipse")

                    



                  -- launch a mail programm

                  , ((windowsKey, xK_m ), runOrRaiseNext "kmail" (className =? "Kmail"))



                  -- switch kb to de

                  , ((windowsKey, xK_BackSpace), spawn "setxkbmap de")



                  -- switch kb to us

                  , ((windowsKey .|. shiftMask, xK_BackSpace), spawn "setxkbmap us")



                  -- launch pidgin

                  , ((windowsKey, xK_i ), runOrRaiseNext "pidgin" (className =? "Pidgin"))



                  -- sound & media

                  , ((windowsKey, xK_v), runOrRaiseNext "rhythmbox" (className

                                                                        =? "Rhythmbox"))

                    

                  -- put system into hibernate mode

                  , ((windowsKey .|. shiftMask .|. controlMask, xK_r), spawn "sudo reboot")

                    

                    

                  -- Toggle docks gaps

                  , ((windowsKey , xK_b), sendMessage ToggleStruts)



                  -- prompt, runOrRaise

                  , ((windowsKey .|. controlMask, xK_x), runOrRaisePrompt

                                                       defaultXPConfig)

                  , ((windowsKey, xK_F1), manPrompt defaultXPConfig)

                    

                  -- finding windows

                  , ((windowsKey, xK_g ), windowPromptGoto

                                        defaultXPConfig { autoComplete = Just 500000 } )

                  ]

                    ++

                    -- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3

                    -- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3

                    --

                    [((m .|. windowsKey, key), screenWorkspace sc >>= flip whenJust (windows . f))

                         | (key, sc) <- zip [xK_e, xK_w, xK_r] [0..]

                    , (f, m) <- [(W.view, 0), (W.shift, shiftMask)]]

place this in ~/.xmonad/xmobarrc:



Config { font = "-*-Fixed-Bold-R-Normal-*-13-*-*-*-*-*-*-*"

, bgColor = "black"

, fgColor = "grey"

, position = TopW L 95

, lowerOnStart = True

, commands = [ Run Memory ["-t","Mem: %"] 10

, Run Swap [] 10

, Run Battery ["-t","Batt: "] 10

, Run Thermal "THRM" [] 10

, Run Network "eth0" ["-L","0","-H","32","--normal","green","--high","red"] 10

, Run Memory ["-t","Mem: %"] 10

, Run MultiCpu ["-t", "CPU: ","-L","3","-H","50","--normal","green","--high","red"] 10

, Run Date "%a %b %_d %Y %H:%M:%S" "date" 10

, Run StdinReader

]

, sepChar = "%"

, alignSep = "}{"

, template = "%StdinReader%} {%multicpu% << %memory% << %swap% << %eth0% << %date%"

}

Installing GHC 6.12.2 on Red Hat Entrprise Linux 5.4 (i386)

2010-05-13T13:36:00.017+02:00

Haskell, a general-purpose, purely functional programming language, has become more and more interesting for me, it allows me to write maintainable code, with acceptable performance even for tasks like analyzing large log files. I recently discovered how easy it is to write programs interacting with a unix like environment. It also very easy to write networking code. Haskell offers great opportunities for TDD and SDD through HUnit and QuickCheck, which - together with the pure and strong static type system of the language itself - enable trust in program correctness, which is vital for many commercial applications, or applications exposed to increased security requirements.

In order to leverage the outstandingly great features of Haskell, one has to have that beast running on a stable, proven and hence archaic and outdated operating system. Even if one is not a firm believer in magical awesomeness of Enterprise labels on top of ridiculously obsolete tools(like gcc 4.1 and glibc 2.5), the server landscape might require to use a specific Linux distribution, because of proprietary drivers for specialized hardware components, in this post I will assume that this Linux distro is Red Hat Entrprise Linux 5.4 and explain the cumbersome installation of the latest and greatest Haskell compiler.

Step 0: Preparing the build environment

As a non-commercial 100% binary compatible replacement for RHEL with only the proprietary art work replaced Cent OS should be used. I installed Cent OS 5.4 i386 without any GNOME or KDE and with bridge networking in a Virtual Box with on an Arch Linux host.

Step 1: Installing GHC 6.8.3

Because the generic binary linux distribution of GHC 6.12.2 depends on at least the 2.7 version of glibc, and RHEL 5.4 only provides glibc 2.5, it is necessary to build it from the sources. Strangely the GHC source distribution needs an existing GHC to compile it: in order to compile GHC 6.12.2 from source we need to have a GHC already installed. The latest GHC version with a generic linux binray distribution compatible with glibc 2.5 is GHC 6.8.3.

These are the required commands(execute as root) to install GHC 6.8.3 into /usr/local:


[root@noname ~]# wget http://haskell.org/ghc/dist/6.8.3/ghc-6.8.3-i386-unknown-linux.tar.bz2
[root@noname ~]# tar xvfj ghc-6.8.3-i386-unknown-linux.tar.bz2
[root@noname ~]# cd ghc-6.8.3
[root@noname ghc-6.8.3]# ./configure
[root@noname ghc-6.8.3]# make install

Try running ghci, the interactive Haskell REPL, it should start and welcome its user with a warm...


[root@noname ~]# ghci
GHCi, version 6.8.3: http://www.haskell.org/ghc/  :? for help
Loading package base ... linking ... done.
Prelude>

Step 2: Building GHC-6.12.2

GHC 6.12.2 can now be built from source using the GHC 6.8.3 from the previous build...


wget http://haskell.org/ghc/dist/6.12.2/ghc-6.12.2-src.tar.bz2
tar xfvj ghc-6.12.2-src.tar.bz2
cd ghc-6.12.2
./configure
make

STOP do not make install just yet. Before, move your /usr/local/ to /usr/local.ghc683 in order to get a clean
install of GHC 6.12 in /usr/local with make install.

Harvest the result of your hard work

Now would be an excellent moment to save a snapshot of your /usr/local directory.
If I knew where I would even upload an archived version of mine.

haskell stuff in my .emacs

2010-05-09T10:11:00.002+02:00

This does not include the ghc-mod configuration.

;; haskell section:
(load "/usr/share/emacs/site-lisp/haskell-mode/haskell-site-file.el")
(require 'inf-haskell)
(autoload 'turn-on-haskell-doc-mode "haskell-doc" nil t)
(add-hook 'haskell-mode-hook 'heyllStd)
(add-hook 'haskell-mode-hook 'turn-on-haskell-font-lock)
(add-hook 'haskell-mode-hook 'turn-on-haskell-decl-scan)
(add-hook 'haskell-mode-hook 'turn-on-haskell-indent)
(add-hook 'haskell-mode-hook 'turn-on-haskell-doc-mode)
(add-hook 'haskell-mode-hook 'turn-on-haskell-ghci)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Regular Expression Cheat Sheet YEAHH!!

2009-10-19T19:13:00.007+02:00

...NOT! There seems to be no good regex escaping cheat-sheet, that is easy to find.
I was so tired of remebering when to escape what in grep, awk, sed and emacs, that I asked google for help. The result of my search was not very satisfying :(

So I started this blogpost as the location for gathering all diffrent escaping styles that I find during my daily work.

sed

\(\)
\+
*
.
\/ (backslash must be escaped, even if not used as seperator cahracter)
\|

grep
Like sed.

I know this isn't twitter but...

2009-07-07T20:30:00.002+02:00

What do they say about a Job?

0. Create it.

- if that doesn't work -
1. Love it.

- if that doesn't work -
2. Change it.

- if that doesn't work -
3. Leave it.

it

2009-06-09T01:27:00.003+02:00

it

syllables stroke hidden performances, relentlessly
while she is singing
with his song she - flowers and shines in a shower
half through and yet stuck
off by an occurence - hesitating

wandering through grayness colorfull her tears
hidden permitted to beast
breaks old and new and she will see
he is falling unforgottenly muted

blended by invisable light not so pure
not shining - hesitate!
clicked links to the past before her metamorphoses
cuting moments of pain and pity

grayness wandering colorfull through his tears
stainless trees fallen in the way
running in a direction and the other
where will we go from here?

I was there...

2009-06-09T01:15:00.002+02:00

http://www.youtube.com/watch?v=PDFrEZ8hqOA

New project started: tabloid

2009-04-15T00:33:00.005+02:00

link

Erlang mock - erlymock

2009-02-25T20:11:00.010+01:00

NOTE THIS POST IS OUTDATED!

The project has evolved and can be found here: ErlyMock

Some features

Easy to use

Design based on easymock

Works together with otp: can be used even if the clut is called from another process, by invoking mock:verify_after_last_call(Mock,optional: timeout)

custom return functions

predefined return functions for returning values, receiving message, throwing exceptions, etc..

erlymock automatically purges all modules that were mocked, after verify()

Custom argument matchers:


%% Orderchecking types: in_order, out_of_order, stub;  
%% Answering: {return, ...}|{error, ...}|{throw, ...}|{exit, ...}|{rec_msg, Pid}|{function, Fun(Args) -> RetVal}
expect(Mock, Type, Module, Function, Arguments, Answer = {AT, _}) when AT==return;AT==error;AT==throw;AT==exit;AT==rec_msg;AT==function ->
    call(Mock, {expect, Type, Module, Function, length(Arguments), {Arguments, Answer}}).

%% this version of expect is suited for useing custom argument matchers
expect(Mock, Type, Module, Fun, Arity, MatcherFun, Function) ->
    call(Mock, {expect, Type, Module, Fun, Arity, {custom, MatcherFun, Function}}).

multiple module per mock

basic usage

in a typicall unit test you will mock certain dependencies. In order to be able to mock function call in the erlang environment you need hot code swapping to
replace the actual implementations with mock functions that look exactly like their orignals to the outside, but that talk to a mock control process,
that you control in order to assert, that functions are called in the correct order and with corrent parameters.
Mocking a process is easier as you can always create a mock process that you smuggle into the code under test.
With erlymock however, you can do both at ease.

The general skeleton of unit test looks like this:


xxx_test() ->
 M = mock:new(),
 ...
 mock:strict(M, ModulToMock, FunctionToMock, ArgumentLiteralList, AnswerDefinition)
 ...
 mock:replay(M)
 ...
  do the actual testing
 ...
 mock:verify(M)

Please refer to the easymock for java documentation to understand the basic principles behind this.
Restrictions

Do not mock system modules.

at the moment only whole modules can be replaced, it is not possible(nor desirable in most cases) to mix original module code and generated mock code

API

There are only eight public function calls, of wich only 5 are neede for most tasks. They are:


new() -> Mock

use this to create a new instance of a mock process that is in programming phase


expect(Mock, OrderCheckingType, Module, Function, Arguments, Answer)

expect has the following options:
Orderchecking types:

in_order all calles flaged in_order must be called in the order recorded, an out of order or stub call will not effect the order of stub call. in_order calls have the highest priorite, they are always check before out of order calls or stub calls. That allows for intermixing of calls to the same functions from all three classes. However if possible in_order calls will be matched before oo and stub calls. All in_order call must occur in the correct order.
out_of_order the main diffrences to in_order calls is that these calls may come in any order, but they must still all be made
stub stub calls are not checked at all, stub calls are usefull for providing fixtures, think of it as comfort noise for the class under test.

Answering:

The last parameter of the expect function defines the answer. It is tuple where the first element is one of the following described atoms,

{return, Value} allows you to just specify a value that will be returned from the function call

{error, Reason} specifies that a certain error will be thrown with erlang:error(Reason)

{throw, What} will make the function throw an exception when called

exit this will cause the function to call exit when invoked

{rec_msg,...} this will caus teh function to make a receive, receiving any message and sending it to a pid

{function, F} when the function is invoked, a user defined function can be passed as parameter. The function will be called with the arguments of the mock invocation in an array

Convenience functions

A variant of expect is suited for using custom argument matchers:


expect(Mock, Type, Module, Fun, Arity, MatcherFun, Function)

A short cut for

expect(.., in_order, ..)

is:


strict(Mock, M,F,Args, Answer)

A short cut for

expect(.., out_of_order, ..)

is:

o_o(Mock, M,F,Args, Answer)

A short cut for

expect(.., stub, ..)

is:

stub(Mock, M,F,Args, Answer)

After the programming phase call this to switch to the replay phase:


replay(Mock)

After the verification phase use this to verify that all expected invocations occured:


verify(Mock)

Example code

These are the unit tests for erlymock, they have a certain documentory value...


-module(testtest).
-compile(export_all).

suite() ->
  test0(),
  test0a(),
  test0b(),
  test0c(),
  test0d(),
  test0e(),
  test1(),
  test2(),
  test3(),
  test3a(),
  test3b(),
  test4(),
  test4a(),
  test5(),
  test6(),
  test6a(),
  test7(),
  test7a(),
  io:format("~n~nfinished without unexpected errors! error reports may be ignored!!~n~n~n").

test0() ->
  Mock = mock:new(),
  mock:expect(Mock, in_order, testmodule1, mockme1, [1,2], {return, ok}),
  mock:expect(Mock, in_order, testmodule1, mockme2, [2,3], {return, ok}),
  mock:expect(Mock, in_order, testmodule2, mockme2, [3,2], {return, ok}),
  mock:expect(Mock, in_order, testmodule2, mockme1, [1,2], {return, ok}),

  mock:replay(Mock),

  testmodule1:mockme1(1,2),
  testmodule1:mockme2(2,3),
  testmodule2:mockme2(3,2),
  testmodule2:mockme1(1,2),

  mock:verify(Mock).

test0a() ->
  Mock = mock:new(),
  mock:expect(Mock, in_order, testmodule1, mockme1, [1,2], {return, ok}),
  mock:expect(Mock, in_order, testmodule1, mockme2, [2,3], {return, ok}),
  mock:expect(Mock, in_order, testmodule2, mockme2, [3,2], {return, ok}),
  mock:expect(Mock, in_order, testmodule2, mockme1, [1,2], {return, ok}),

  mock:replay(Mock),

  testmodule1:mockme1(1,2),
  testmodule1:mockme2(2,3),
  {'EXIT',_} = (catch testmodule2:mockme1(1,2)).

test0b() ->
  Mock = mock:new(),
  mock:expect(Mock, in_order, testmodule1, mockme1, [1,2], {return, ok}),
  mock:expect(Mock, in_order, testmodule1, mockme2, [2,3], {return, ok}),
  mock:expect(Mock, in_order, testmodule2, mockme2, [3,2], {return, ok}),
  mock:expect(Mock, in_order, testmodule2, mockme1, [1,2], {return, ok}),

  mock:replay(Mock),

  testmodule1:mockme1(1,2),
  testmodule1:mockme2(2,3),
  testmodule2:mockme2(3,2),

  {error, _} = mock:verify(Mock).

test0c() ->
  Mock = mock:new(),
  mock:strict(Mock, testmodule1, mockme1, [1,2], {return, ok}),
  mock:o_o   (Mock, testmodule1, mockme2, [2,3], {return, ok}),
  mock:strict(Mock, testmodule2, mockme2, [3,2], {return, ok}),
  mock:o_o   (Mock, testmodule2, mockme1, [1,2], {return, ok}),

  mock:replay(Mock),

  testmodule1:mockme1(1,2),
  testmodule2:mockme2(3,2),
  testmodule2:mockme1(1,2),
  testmodule1:mockme2(2,3),

  mock:verify(Mock).

test0d() ->
  Mock = mock:new(),
  mock:strict(Mock, testmodule1, mockme1, [1,2], {return, ok}),
  mock:o_o   (Mock, testmodule1, mockme2, [2,3], {return, ok}),
  mock:strict(Mock, testmodule2, mockme2, [3,2], {return, ok}),
  mock:o_o   (Mock, testmodule2, mockme1, [1,2], {return, ok}),

  mock:replay(Mock),

  testmodule1:mockme1(1,2),
  testmodule2:mockme2(3,2),
  testmodule2:mockme1(1,2),

  {error, _} = mock:verify(Mock).

test0e() ->
  Mock = mock:new(),
  mock:strict(Mock, testmodule1, mockme1, [1,2], {return, ok}),
  mock:o_o   (Mock, testmodule1, mockme2, [2,3], {return, ok}),
  mock:strict(Mock, testmodule2, mockme2, [3,2], {return, ok}),
  mock:o_o   (Mock, testmodule2, mockme1, [1,2], {return, ok}),

  mock:stub  (Mock, testmodule3, mockme, [666], {return, ok}),
  mock:stub  (Mock, testmodule3, mockme, [777], {return, ok}),
  mock:stub  (Mock, testmodule3, mockme, [888], {return, ok}),
  mock:stub  (Mock, testmodule3, mockme, [999], {return, ok}),

  mock:replay(Mock),

  ok = testmodule1:mockme1(1,2),
  ok = testmodule2:mockme2(3,2),
  ok = testmodule3:mockme(777),
  ok = testmodule2:mockme1(1,2),
  ok = testmodule3:mockme(777),
  ok = testmodule3:mockme(888),
  ok = testmodule1:mockme2(2,3),
  ok = testmodule3:mockme(777),

  mock:verify(Mock).

test1() ->
  Mock = mock:new(),
  mock:replay(Mock),
  mock:verify(Mock).

%error expected
test2() ->
  Mock = mock:new(),
  mock:strict(Mock, testmodule, mockme, [1,2],{return, ok}),
  mock:replay(Mock),
  {error, _} = mock:verify(Mock).


test3() ->
  Mock = mock:new(),
  mock:strict(Mock, testmodule2, mockme1, [666], {error, end_of_times}),
  mock:replay(Mock),
  try testmodule2:mockme1(666) of
 _ ->
      exit(error_expected)
  catch
 error:end_of_times ->
     ok
  end.  

test3a() ->
  Mock = mock:new(),
  mock:o_o(Mock, testmodule2, mockme1, [666], {throw, end_of_times}),
  mock:replay(Mock),
  try testmodule2:mockme1(666) of
 _ ->
      exit(error_expected)
  catch
 throw:end_of_times ->
     ok
  end.  

test3b() ->
  Mock = mock:new(),
  mock:strict(Mock, testmodule2, mockme1, [666], {exit, end_of_times}),
  mock:replay(Mock),
  try testmodule2:mockme1(666) of
 _ ->
      exit(error_expected)
  catch
 exit:end_of_times ->
     ok
  end.  

test4() ->
  Mock = mock:new(),
  {error,_} = mock:verify(Mock).

test4a() ->
  Mock = mock:new(),
  {'EXIT',_} = (catch mock:strict(Mock, testmodule1, mockme1, [1,2], {hier_steht_was_falsches, xxx})).

test5() ->
  Mock = mock:new(),
  mock:strict(Mock, testmodule1, mockme1, [1,2], {rec_msg, self()}),
  mock:replay(Mock),
  TestPid = spawn(testmodule1,mockme1,[1,2]),
  TestPid ! test,
  receive
 test ->
     ok,
     mock:verify(Mock)
  after 1000 ->
     error
  end.

test6() ->
  Mock = mock:new(),
  mock:o_o(Mock, testmodule1, mockme1, [1,2], {function, fun(X,Y) ->
            X + Y
           end}),
  mock:replay(Mock),
  R = testmodule1:mockme1(1,2),
  mock:verify(Mock),
  3 = R.

test6a() ->
  Mock = mock:new(),
  mock:stub(Mock, testmodule1, mockme1, [1,2], {function, fun(_,_) ->
            erlang:error(test)
           end}),
  mock:replay(Mock),
  {'EXIT',_} = (catch testmodule1:mockme1(1,2)),
  mock:verify(Mock).

test7() ->
  Mock = mock:new(),
  mock:expect(Mock, in_order, testmodule1, mockme1, 1,
  fun([{qXYZ, D, B, A}]) when A >= B andalso B >= D ->
   true
  end,
  {function, fun({qXYZ, D, B, A}) ->
   [B,D|A]
  end}
        ),
  mock:replay(Mock),
  L = testmodule1:mockme1({qXYZ, 1,2,3}),
  mock:verify(Mock),
  [2,1|3] = L.

test7a() ->
  Mock = mock:new(),
  mock:expect(Mock, in_order, testmodule1, mockme1, 1,
  %% hier fehlen die obligatorischen Klammern
  fun({qXYZ, D, B, A}) when A >= B andalso B >= D ->
   true
  end,
  {function, fun({qXYZ, D, B, A}) ->
   [B,D|A]
  end}
        ),
  mock:replay(Mock),
  {'EXIT',_}= (catch testmodule1:mockme1({qXYZ, 1,2,3})).

Most important: erlymock source code

Contents of file mock.erl:


-module(mock).
-export([await/1,await/2,signal_fun/2,new/0, expect/7, expect/6, strict/6, strict/5, o_o/5, stub/5, replay/1, verify/1, verify_after_last_call/1, verify_after_last_call/2, invocation_event/1]).

-author('Sven Heyll').
-version(2).

%% use this to create a new instance of a mock process that is in programming phase
new() ->
    Mock = spawn_link(fun() -> program_mock([],[],[]) end),
    error_logger:info_msg("mock ~w: created~n", [Mock]),
    Mock.

%% expect has the following options:
%% Orderchecking types: in_order, out_of_order, stub;  
%% Answering: {return, ...}|{error, ...}|{throw, ...}|{exit, ...}|{rec_msg, Pid}|{function, Fun(Args)} -> RetVal}|{function1, Fun(ArgList)}
expect(Mock, Type, Module, Function, Arguments, Answer = {AT, _}) when is_list(Arguments), AT==return;AT==error;AT==throw;AT==exit;AT==rec_msg;AT==function;AT==function1 ->
    call(Mock, {expect, Type, Module, Function, length(Arguments), {Arguments, Answer}}).

%% this version of expect is suited for useing custom argument matchers
expect(Mock, Type, Module, Fun, Arity, MatcherFun, Answer) when is_integer(Arity), is_function(MatcherFun)->
    call(Mock, {expect, Type, Module, Fun, Arity, {custom, MatcherFun, Answer}}).
    
%% this is a short cut for expect(.., in_order, ..)
strict(Mock, M,F,Arity, Fun, Answer) when is_integer(Arity)->
    expect(Mock, in_order, M, F, Arity, Fun, Answer).

%% this is a short cut for expect(.., in_order, ..)
strict(Mock, M,F,Args, Answer) ->
    expect(Mock, in_order, M, F, Args, Answer).

%% this is a short cut for expect(.., in_order, ..)
o_o(Mock, M,F,Args, Answer) ->
    expect(Mock, out_of_order, M, F, Args, Answer).

%% this is a short cut for expect(.., in_order, ..)
stub(Mock, M,F,Args, Answer) when is_list(Args)->
    expect(Mock, stub, M, F, Args, Answer);

%% this is a short cut for expect(.., in_order, ..)
stub(Mock, M,F,Arity, Answer) when is_integer(Arity) ->
    expect(Mock, stub, M, F, Arity, fun(_) -> true end, Answer).

%% after the programming phase call this to switch to the replay phase
replay(Mock) ->
    call(Mock, replay).

%% after the verification phase use this to verify that all expected invocations occured
verify(Mock) ->    
    verify_after_last_call(Mock, 0).

%% after the verification phase use this to verify that all expected invocations occured
verify_after_last_call(Mock) ->
    verify_after_last_call(Mock, 1500).
verify_after_last_call(Mock, TimeOut) ->
    catch(await(invocation_list_empty, TimeOut)),
    call(Mock, verify),
    await(cleanup_finished),
    error_logger:info_msg("mock ~p: verify finished~n~n~n", [Mock]).


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% utility functions for dealing with mock code called from a new process.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% this will create an answering function that captures the current pid and
%% sends an atom to that pid, make sure to use await(atom()) to block until that
%% message is sent 
signal_fun(Atom, RetVal) ->
    SelfP = self(),
    {function1, fun(_) -> 
   signal(SelfP, Atom),
   RetVal
  end}.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%    
%% internal signal function that send a message in "signal" protocol format to
%% some "await(...)"
signal(Pid, Atom) ->
    error_logger:info_msg("signalling ~p from  ~p to ~p~n", [Atom, self(), Pid]),
    Pid ! {mock_signal, Atom}.
    
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% this block the current process until signal(SameAtom) from another process is
%% invoked
await(Atom) when is_atom(Atom) ->
    await(Atom, 2000).

await(Atom,To) when is_atom(Atom)->       
    error_logger:info_msg("now awaiting ~p in process ~p~n", [Atom, self()]),
    receive
 {mock_signal, Atom} ->
     error_logger:info_msg("await succeeded: ~p~n", [Atom])
    after To ->
     fail({timeout, await, Atom})
    end.
 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

fail(Pid, Reason) ->
    error_logger:info_msg("mock ~w: failed: ~w~n",[self(), Reason]),
    Pid ! {error, Reason}.

fail(Reason) ->
    error_logger:info_msg("mock ~w: failed: ~w~n",[self(), Reason]),
    throw({mock_failure, Reason}).

success(Pid) ->
    Pid ! {response, ok},
    success().

success() ->
    error_logger:info_msg("mock ~w: successfully finished.~n",[self()]),
    test_passed.    

call(Name, Request) ->
    Name ! {self(), Request},
    receive
 {error, Reason} ->
     throw({mock_failure, Reason});
 {response, Response} ->
     Response
    end.

filter_fun(_, _, _, {Arguments, _}) ->    
    fun(Args) ->
     Args == Arguments
    end;

filter_fun(_, _, _, {custom, Matcher, _}) ->
    Matcher.

answer_fun({_, Answer}) ->    
    Answer;

answer_fun({custom, _, Answer}) ->
    Answer.

module_header_abstract_form(Mod) ->
    [{attribute,0,module,Mod}, 
    {attribute,0,compile,[export_all]}].

fundef_to_abstract_meta_form(Self, Mod, FunName, Arity) ->
    Line = 1,
    Params = [{var, Line, list_to_atom("A" ++ integer_to_list(I))} || I <- seq(1,Arity)],
    {function, Line, FunName, Arity,
     [{clause, Line, 
       Params, [], 
       [{call, Line, 
  {remote, Line, {atom, Line, mock}, {atom, Line, invocation_event}}, 
  [{tuple, Line, 
    [{string,Line, Self}, {atom, Line, Mod}, {atom,Line, FunName}, {integer, Line, Arity},
     lists:foldr(
       fun(E,R) ->
        {cons, Line, E, R}
       end, 
       {nil, Line}, 
       Params)]}]}]}]}.

compile_and_load_abstract_form(AbsForm) ->
    CompRes = compile:forms(AbsForm),
    {ok, Mod, Code} = CompRes,
    code:purge(Mod),
    code:delete(Mod),
    {module, _} = load_module(Mod, Code).

extract_module_set(Combined) ->
    sets:from_list(lists:map(fun([{M,_,_}|_]) -> M end, Combined)).

program_mock(InOrder, OutOfOrder, Stub) ->
    receive 
 {From, {expect, Type, Mod, Fun, Arity, Arg}} ->
     FunDef = [{Mod, Fun, Arity} | {filter_fun(Mod,Fun,Arity,Arg), answer_fun(Arg)}],
     From ! {response, ok},
     case Type of 
  in_order ->
      program_mock([FunDef | InOrder], OutOfOrder, Stub);
  out_of_order ->
      program_mock(InOrder, [FunDef | OutOfOrder], Stub);
  stub ->
      program_mock(InOrder, OutOfOrder, [FunDef | Stub])
     end;

 {From, replay}  ->
     Self = pid_to_list(self()),
      Combined = InOrder ++ OutOfOrder ++ Stub,
      ModuleSet = extract_module_set(Combined),
      sets:fold( fun (Mod, _) ->
          FunsOfModSet = sets:from_list(
      lists:foldl(
        fun([{M,F,A}|_], Acc) -> 
         if Mod == M -> [{F,A}|Acc];           
            true -> Acc
         end
        end, [], Combined)),
          HeaderForm = module_header_abstract_form(Mod),
          FunctionForms = sets:fold(
       fun({F,A},FFAcc) -> 
        [fundef_to_abstract_meta_form(Self, Mod, F, A)|FFAcc]
       end,
       [],
       FunsOfModSet),
          CLRes = compile_and_load_abstract_form(HeaderForm ++ FunctionForms),
          error_logger:info_msg("mock ~w: created and loaded mock code ~w~n",[self(),CLRes])
         end,
         [],
         ModuleSet),
       From ! {response, ok},
     %% spawn a cleanup process that will call the uninstall fun
     auto_cleanup(fun() ->
     uninstall(ModuleSet),
     signal(From, cleanup_finished)
    end),
      record_invocations(lists:reverse(InOrder), 
          OutOfOrder, 
          Stub,
          fun() -> 
           signal(From, invocation_list_empty) 
          end
         );
 {From, What} ->     
     fail(From, {invalid_state, What})
    end.
 
record_invocations([], [], Stub, EmptyFun) when is_function(EmptyFun) ->
    EmptyFun(),
    record_invocations([], [], Stub, undefined);
record_invocations(InOrder, OutOfOrder, Stub, EF) ->
    %% wait for all incoming invocations, expect every invocation and crash if the invocation was not correct
    receive
 Invocation = {ProcUnderTestPid, Mod, Fun, Arity, Args} ->
     InvMatcher = fun ([{M,F,A}|{Pred,_}]) ->
     {M,F,A} == {Mod, Fun, Arity} andalso Pred(Args)
    end,
     try 
  case InOrder of
      [Test| _] ->  InvMatcher(Test);
      [] -> false
  end
  of
  true ->       
      [[_|{_,Function}]| IOR] = InOrder,
      ProcUnderTestPid ! {mock_process_gaurd__, Function},
      record_invocations(IOR, OutOfOrder, Stub, EF);

  false -> 
      case lists:splitwith(InvMatcher, OutOfOrder) of
   {[OOODef|Rest1],Rest2} ->
       [_|{_,Function}] = OOODef,        
       ProcUnderTestPid ! {mock_process_gaurd__, Function},
       record_invocations(InOrder, Rest1 ++ Rest2, Stub, EF);

   {[], _} ->
       case lists:filter(InvMatcher, Stub) of
    [StubDef|_] ->
        [_|{_,Function}] = StubDef,        
        ProcUnderTestPid ! {mock_process_gaurd__, Function},
        record_invocations(InOrder, OutOfOrder, Stub, EF);

    _ ->
        EF(),
        Reason = {unexpected_invocation, Invocation},
        ProcUnderTestPid ! {mock_process_gaurd__, {error, Reason}},
        fail(Reason)
       end
      end
     catch
  ET:EX -> 
      Reason = {matching_function_is_incorrent, Invocation, {ET, EX}},
      ProcUnderTestPid ! {mock_process_gaurd__, {error, Reason}},
      EF(),
      fail(Reason)
     end; 

 {From, verify} ->
     case {InOrder,OutOfOrder} of
  {[],[]} -> 
      success(From);
  MissingRest ->
      fail(From,{expected_invocations_missing, MissingRest})
     end;

 {From, What} ->
     EF(),
     fail(From, {invalid_state, What})

    end.

invocation_event({MockPidStr, Mod, Fun, Arity, Args}) ->
    MockPid = list_to_pid(MockPidStr),
    error_logger:info_msg("mock ~w: invocation: ~w:~w/~w ~w~n",[MockPid, Mod, Fun, Arity, Args]),
    MockPid ! {self(), Mod, Fun, Arity, Args},
    receive
 {mock_process_gaurd__, {return, Answer}} -> 
     Answer;
 {mock_process_gaurd__, {error, E}} ->
     erlang:error(E);
 {mock_process_gaurd__, {throw, E}} ->
     throw(E);
 {mock_process_gaurd__, {exit, R}} ->
     exit(R);
 {mock_process_gaurd__, {function, F}} ->
     error_logger:info_msg("mock ~w: invoking answerer~n",[MockPid]),     
     R = apply(F,Args),
     error_logger:info_msg("mock ~w: answerer returned: ~w~n",[MockPid,R]),
     R;
 {mock_process_gaurd__, {function1, F}} ->
     error_logger:info_msg("mock ~w: invoking answerer~n",[MockPid]),     
     R = F(Args),
     error_logger:info_msg("mock ~w: answerer returned: ~w~n",[MockPid,R]),
     R;
 {mock_process_gaurd__, {rec_msg, P}} ->
     error_logger:info_msg("mock ~w: receiving message for ~w~n",[MockPid,P]),     
     Msg = receive 
        M ->
     P ! M
    end,
     error_logger:info_msg("mock ~w: message ~w delivered to ~w~n",[MockPid,Msg,P])    
    end.

seq(A, E) when A > E -> [];
seq(A, E) -> lists:seq(A,E).
    
uninstall(ModuleSet) ->
    lists:map(fun(Mod) ->
        error_logger:info_msg("Deleting and purging module ~p~n", [Mod]),
        code:purge(Mod),
        code:delete(Mod)
       end, sets:to_list(ModuleSet)).

auto_cleanup(CleanupFun) ->    
    spawn_link(fun() ->
         erlang:process_flag(trap_exit, true),
         error_logger:info_msg("auto cleanup handler ~p waiting for the end...~n", [self()]),
         receive
      Msg = {'EXIT', _From, _Reason} ->
          error_logger:info_msg("auto cleanup handler ~p receive exit message ~p.~n", [self(), Msg]),
          CleanupFun();
      _Ather -> 
          error_logger:info_msg("auto cleanup handler ~p received unexpected message  ~p.~n", [self(), _Ather])
         end
        end).

my personal profiling guide

2008-11-30T18:45:00.008+01:00

This is suited for functional programming.

Blind optimizations: just say NO.

1. Write some unit tests that ensure your code stays correct.
2. DO NOT ASSUME ANY KNOWLEDGE ON WHAT SHOULD BE OPTIMIZED- but try to "see"
possible bottlenecks.
3. Write a the smallest possible program that uses the code to optimize, such that
the program exhibits the functionality that seems to be the bottleneck(s).
Design this program to run for a few seconds without user interaction.
4. Use a decent profiler to profile a complete run of this program
5. Optimize the bad code in this order
- estimate the complexity of the code around hotspots
- try diffrent data structures and algorithms
- try to involve background knowledge
- try to combine several functions into one
- records should fit into the cache of the target platform
- add more strictness(dangerous)
- move common subexpressions or constant subexpressions to a higher scope(generalisation of precalculation)
- use more efficient primitives(do I really need an arbitrary precission floating point)

Following the steps from above I was able to optimize two new programms each by a factor of about 50(!).

ArrowLoop - finally seeing the light at the end of a long tunnel

2008-09-15T07:18:00.003+02:00

Today I achieved something I long lusted to acheive, I made the step from fix to loop.
Basically by going from the applicative order Y combinator:



(define (y f)
  ((lambda (ff) 
     (lambda (xx)
       (f (ff ff) xx)))
   (lambda (ff) 
     (lambda (xx) 
       (f (ff ff) xx)))))

(define (fak f n)
  (if (= 0 n)
      1
      (* (f (- n 1)) n)))

((y fak) 5)

to writing the same in lazy haskell:



y f = f $ y f

fak r 0 = 1
fak r n = n * r (n - 1)

-- ghci> y fak 5  ----> 120

someone told me that

 fix = y

and that fix and loop are closely related.
I found an aspiring blogpost and thought it would be fun to
do the fibonacci recursion instead of the simple factorial.

That resulted in:



data SF a b = SF {runSF :: [a] -> [b]}

instance Arrow SF where
    arr f = SF (map f)
    (SF f) >>> (SF g) = SF (f >>> g)
    first (SF f) = SF $ unzip >>> (first f) >>> zip'

instance ArrowLoop SF where
    loop (SF f) = SF (\ins -> 
                  let (outs, rs) = (zip' >>> f >>> unzip) (ins, lazy rs)
                  in outs)


lazy ~(z:zs) = z : lazy zs
zip' = uncurry zip
delay n = SF (n:)

{-
  
   The Fibonacci device
        1             2           3             4 

   o----x    ,->(delay b)-.                ,-->(id)------->o
             |            |=>(uncurry (+))-|
   o---------'---(id)-----'                `-->(delay a)-->o

 (the first input is merely a clock source...)                 

 with the loop around:

  

-}
fib n = take n (runSF (loop (fib' 0 1)) [1,1..])
fib' :: (Num a) => a -> a -> SF (a, a) (a, a)
fib' a b = arr snd  >>> -- 1 
           (delay b &&& arr id) >>>  -- 2
           arr (uncurry (+)) >>>  -- 3
           (arr id &&& delay a) -- 4

{-


   The experimental  Fibonacci device
                   1             2                        3                4 
   o-------------------------------------------.                   ,------(id)----->o
             ,->(delay b)-.                    |===> (uncurry (*))-|
             |            |=>(uncurry (+))-----'                   `--->(delay a)-->o
   o---------'---(id)-----'                                    
                  

-}
fibex' :: (Num a) => a -> a -> SF (a, a) (a, a)
fibex' a b = (second 
            ((delay b &&& arr id) >>>  -- 1
                                  arr (uncurry (+))))  -- 2
           >>>
           (arr (uncurry (*))) >>> -- 3
                   ((arr id) &&& (delay a)) -- 4


fibex n = take n (runSF (loop (fib' 0 1)) [1..])

That was/is really fun. I like haskell.

Got Religious

2008-08-08T01:39:00.007+02:00

[this is the only religious post you will ever encounter on this blog]

After an excessive amount of thinking, reading and
weighting pros and cons I came to the final conclusion that
actually and deep down in me, I beleive that
1. God exists
2. Christianity makes sense

Many, many arguments exits against 1 and also 2.

But as soon as you accept 1. arguing against 2 becomes
really hard. All objections brought into field against 2. failed to
convince me finally; ok some of them convinced me at first,
and it took years to find out that they were errornous.
Many objections seem clever at first, but really contain
discrepancies or stem from pure ignorance.
Most of those uttering them, do not really reflect
these objections very well. A nice example is
the following "objection" against 1. and partly 2.:
"If god was almighty, could he create a
stone so heavy, that he can't lift it?"
It takes a bit of thinking, but is actually easy to debilitate. I will
leave that as an exercise to the reader, I really don't want to
take the fun out of this; I am sure, that also atheists will
see the inherent logical problems in this objection :)

I think that most religions can be unified to a common theme,
I therefore believe, that some religions contain an abstract
common base, that is below a thick tangible layer of
"stories" - I prefer christianity, as it is the only one
I know just good enough, to see how deeply consistent and
consistent everything is. Although some peices seem odd or
paradox at first, they make sense if you dig deeper and
think about them...

Regarding 1. How could a reasonable scientist exclude
the existence of god, without leaving many
questions open, and without entangling themselves in inconsistencies?
Well even if my ignorance/stupidity is not a
convincing argument that 1. is true, and you believe that
something in this world *whatever that is* exists, you end up
beleiving in some immaterial properties - one way or the other.
I beleive that these properties exist (and might even be corner stones of a
creation done be an intentional, allmighty being, which some call god) and are
basic expressions of the Holy Ghost - as are the brain brain activities,
that ask themselves now, wether this make sense or not.

So ... please do not assume that I will bother anyone with my personal beleivesystem
anymore, I just wanted share these thoughts, that's all I'll ever write about that
topic.

Erlang code snippet....

2008-08-07T02:26:00.004+02:00

Code like that:


blah(X) ->
  X1 = f(X),
  X2 = g(X1),
  X3 = h(X2),
  i(X3).

is very error prone, and worse very hard to extend. Just adding another
function application between f(X) and g(X1) requires you to alter all lines
upto the end of the function:


blah(X) ->
  X1 = f(X),
  X2 = j(X1)
  X3 = g(X2),
  X4 = h(X3),
  i(X4).

This causes 2*numberoflinestoendoffunction potential error sources;

And this is also not at all a very functional style.
Why not rewriting it like this:


blah(X) -> 
    (chain([
       f,
       g,
       h,
       i
      ]))(X).

where one chains together the functions. Adding a function invocation in between is as easy as pie.


chain(FunList) ->
  lists:foldl(
    fun combine/2,
    fun id/1,
    FunList). 
 
id(X) -> X.

combine(F,G) ->
    RF = to_local_function(F),
    RG = to_local_function(G),
    fun(X) ->
     RF(RG(X))
    end.

to_local_function(F) ->
    case F of 
 {FM, FF} -> F;
 _ when is_atom(F) -> {?MODULE, F}
    end.

Another solution might be using the state monad, wich was
built for dealing with this kind of functional composition.

Lazy Evaluation(there be dragons and basement cats)

2008-08-04T15:41:00.015+02:00

Lazy Evaluation and "undefined"

I am on the road to being a haskell programmer, and it still is a long way to go. Yesterday I had some nice guys from #haskell explain to me lazy evaluation.

Take a look at this code:


Prelude> let x = undefined in "hello world"
"hello world"
Prelude>

Because of Haskells lazyness, x will not be evaluated because it is not used, hence undefined will not be evaluated and no exception will occur.

The evaluation of "undefined" will result in a runtime exception:


Prelude> undefined
*** Exception: Prelude.undefined
Prelude>

Strictness

Strictness means that the result of a function is undefined, if one of the arguments, the function is applied to, is undefined.
Classical programming languages are strict. The following example in Java will demonstrate this. When the programm is run, it will throw a RuntimeException, although the variable "evilX" is never actually used, strictness requires that all
arguments of a function are evaluated before that function is applied to(called with) these values:



public class Strictness {
 public static void main(String[] args) {
  int evilX = 1/0;
  report_result("sven", evilX);
 }

 private static void report_result(String name, int x) {
  System.out.println("None cares about what "+name + " actually calculated...");
 }

}

When executed, the output of the program is:


Exception in thread "main" java.lang.ArithmeticException: / by zero
 at com.blogspot.sheyll.strictness.Strictness.main(Strictness.java:10)

A non-strict Haskell equivalent:


module StrictnessFP where

report_results name x = putStrLn $ "None cares about what " ++ name ++ " actually calculated..."

main = let evilX = 1/0 in
        report_results "Sven" evilX

When executed the following output appears:


[1 of 1] Compiling StrictnessFP     ( C:/Users/sheyll/workspace/StrictnessFP/src/StrictnessFP.hs, interpreted )
Ok, modules loaded: StrictnessFP.
*StrictnessFP> main
None cares about what Sven actually calculated...

Enforcing strictness

Sometimes it makes sense to enforce strictness, in order to optimize the runtime performance. Lazy evaluation means that every value is encapsulated in a thunk, a
function without paramaters, which is passed around instead of the actual value, and which is evaluated if needed. This might cause some overhead, compared to passing around the value directly.
Another point to note is that evaluation order is undetermined, values are evaluated as needed, and therefore only as consequence to the interaction with the real world aka the IO Monad.
In Haskell there is a standard operator to enforce strictness:


seq:: a -> t -> t

With the semantics:


seq a t = if a /= undefined then t else undefined

THIS CODE WILL NOT RUN because the result of comparing something with undefined is always undefined, still this illustrates the idea, that seq will check(evaluate and throw away the result) its first parameter and only return the second parameter if the first did not evaluate to undefined.
Why is this construct usefull?
In case where we have the following structure, and want to optimize the performance and/or space requirements:


complex_calculation x = seq x (... x ....)

"seq" therefore ensures the order of evaluation, that's why it is called "seq".

The following code will output the string "None cares about what Sven actually calculated...":


report_results name x = putStrLn ("None cares about what " ++ name ++ " actually calculated...")

main = report_results "Sven" undefined

Whereas the next version, that incorporates "seq", will throw an Exception at runtime:


report_results name x = seq x (putStrLn ("None cares about what " ++ name ++ " actually calculated..."))

main = report_results "Sven" undefined

Evaluation means reduction to weak head normal form

Simon Peyton Jones, one of the greatest Haskell-Hackers out there, coined the term
"Weak Head Normal Form"(WHNF).
In contrast, the "Head Normal Form"(HNF) requires, that during execution an expression must be reduced until it cannot be further reduced, i.e. all applyable lambda expressions must be applied.
Whereas the WHNF is reached as soon as a lambda expression is achieved, even if it could be reduced further till finally the HNF is reached.
Requirering reduction only to WHNF allows the program to stop the process of reduction, which actually is the process of executing the program, when a value is passed to a function, also if the value ist yet to be calculated by the application of another function.
Requirering reduction to WHNF instead of HNF also allows the reuse of computation results and also helps a lot when implementing "lazy evaluation" in the compiler, because an algorithm called graph reduction can be used.
Please search the net for weak head normal form.
This concludes the theoretical part of this post. The next chapter will deal with
a very practical issue:

There be Dragons: Stackoverflow!

Everyone loves these two higher order functions foldr, foldl.
Here is a possible definition of foldl that's close enough to reality:


my_foldl f a (b:bs) = my_foldl f (f a b) bs
my_foldl _ a [] = a

If that definiton is used in the function below, we get a stack overflow exception:


stack_overflow = my_foldl (\x y -> x + y) 0 [1..1000000]

Because the x+y operations are contained in thunks, that pile up until the stack is full, because they are not evaluated! If they were, all that needs to be on the stack is a single integer, the result of each addition.

For exactly that purpose a special version of foldl exists called " foldl' ", it's basically ....

A Strict "foldl"

The Data.List module of the Glasgow Haskell compiler contains a function called
foldl' that has (roughly) the following definition:


my_foldl' f a l = mfl a l
    where mfl a [] = a
          mfl a (x:xs) = let a' = f a x in a' `seq` mfl a' xs

The variable a' contains the thunk for the computation f a x, and seq forces a' to be evaluated which means that the thunk called a' will be evaluated - which forces the application of f to a and x.

In this example f is a lambda expression containing the addition of x and y, in fact
it is similar to the expression that caused the stackoverflow:


no_stack_overflow = my_foldl' (\x y -> x + y) 0 [1..1000000]

- only this time there won't be a stackoverflow:


*StrictnessFP> no_stack_overflow
500000500000

So you think you're save now? Be aware, cause

basement cat is in yar toople!!11oneeleven

What do you expect to be the outcome of the evaluation of basement_cat, as defined
here:


basement_cat = my_foldl' (\(x, y) i -> (i, y + i)) (0,0) [1..10000000]

The surprising result is a stackoverflow, although we are using the strict version of foldl.
The stuff piles up on the stack again, because the tuple construction (i, y+i) adds another layer of laziness ontop of the computation. The tuple itself is evaluated because we use the strict foldl, but the contents of the tuple are laziely chilling in thunks, that will not be evaluated until explicitely forced!

The output of the basement_cat:


*StrictnessFP> basement_cat
(10000000,*** Exception: stack overflow

Note how the first element of the tuple can still be evaluated, but not the second.

So how can one get the desired result? The solution is to use the strictness operator "seq":


ceiling_cat = my_foldl' (\(x, y) i -> let y' = y + i in y' `seq` (i, y')) (0,0) [1..10000000]

When executed the interpreter outputs:


*StrictnessFP> ceiling_cat
(10000000,50000005000000)

Write unit tests. Always. Even in Haskell.

So the conclusion for me is that lazy evaluation offers greate benefits:
* optimization potential through graph reduction
* declarative programming style i.e. thtough infinite lists
* recursive functions and datastructures

On the other hand one has to watch out for stack overflows and strictness issues when using i.e. tuples and lists, and all data constructors, as well as newtype contructors which contain tuples. It is essential to pay special attention to these
issues, because they might be not very obvious, at least for a beginner.

Further more the use of the strictness operator should be clear; it should be noted that it is not easiely possible to implement seq in haskell itself. I think it must somehow be built-in.
As the name already suggests seq fixes the order of evaluation:


a `seq` b

Means first eval a then b.

I am convinced, that especially the beginner needs to write unit tests; even in Haskell there are some non-trivial aspects that might cause unexpected behaviour.

BlogPostAnswer.hs

2008-08-01T03:19:00.002+02:00

Intro


-}
module BlogPostAnswer where

import System.Environment

{-

This is haskell source code, which relates
to a nice blog post of someone comparing
java with python.

Original post

I picked some of the python-java comparisons
from that post, which I would like to
extend in order to contrast java and python
with haskell.

You can actually use the complete post as a
haskell source code file. All prose is
embedded in "{-" and "-}", wich are the block
comment tokens in haskell syntax.

I am a beginner haskell-hacker, and I dont have
a clue about python, so enlighten me, if you spot
a mistake.

Like python, haskell allows you to use indenting
as part of the syntax, unlike python however, you
also have the choice of using "{", "}" and ";"
instead of, or combined with, indentation.

Also, like in python, and unlike java you don't need
to put type declarations into you source code.

The step from java to haskell is
not the step from a statically typed language
to a dynamically typed language. Neither is java
really statically typed, nor is haskell
dynamic.
The opposite is true, haskell has a far stricter static
typesystem than java has, but it uses a variation
of the Hindley-Milner typesystem wich includes
type inference - This effectivly frees one from
writing type specs in most cases.

Haskell has a rich typesystem with all kinds of
good stuff. For someone who knows
C++ template programming, learning haskell might be
easier than learning java 5 generics.

I will try to give code examples in haskell, that
roughly correspond to the java and python code examples
from the blog post.

Plase aquire ghc and load this blogpost as haskell file.
Every piece of code shown here, is complete and can be
executed in the interactice haskell shell called ghci.

Assuming ghci is started in the director where textfile
with this source is located, the following commands
should be typed at the ghci prompt in order to compile and
load the code:


> :l (name of file)

(this loads the code)

Now you can call every function in this source code from the prompt
by writing the name and the arguments of that function seperated by
spaces.
i.e.


> test_matches_2

to run the "main" function, you must compile the file outside the interactive shell and
start the programm from the commandline like this:


bash $ ghc --make (nameofsourcefile)
bash $ ./(nameofsourcefile) "hallo welt"

Again, let me remind the reader, that I am not
a haskell expert, and that there might be far
more elegant ways to do it.

ok, let's get started:

Observation 1: Haskell is a unique mixture of readability and brevity

Java:


public class Test
{
     public static void main(String[] args)
     {
         for (String s : args[0].split("\\s+"))
             System.out.println(s);

         System.exit(0);
     }
}

Haskell:


-}

main = getArgs >>= mapM putStrLn . words . head  

{-

This examples pipes a list of command line parameters into the
functional combination of three functions that do the following in the
order they are listed:

takes the first element and ignores the rest: "head"

seperates this element into a list of words of wich the first element consists

write each word seperated by a newline to the stdout

As you may have noticed:

">>=" pipes data

"." combines two functions to a new function

"mapM f" call the function "mapM" with the parameter "f"

Haskell function application syntax is very similar to the
typical unix shell function invocation syntax.
The name of the function and the arguments are put in a line
next to each other seperated by spaces instead of brackets.

Observation 2: No need for set/get methods in Haskell

One purpose of the 2nd code example from
the above mentioned blogpost is to show off
a nice python feature needed in a language
with mutable state and oo features like instance
variables.

Haskell has neither mutable variables nor objects with variables.
Haskell is a pure funcitonal programming language,
meaning that like erlang, haskell has no notion of
variables that may be changed after being bound.
The typical OO-Class system, having classes with
i.e. setters for properties is not possible in
haskell without rolling your own little object
system (wich isn't hard at all, but also not
necessary).

Haskell provides other means for grouping data.
One way is to use algebraic data types:

Observation 3: Haskell has useful constructs Java lacks

algebraic datatypes

Algeraic data types are those constructs that start with the reserved keyword "data".
They create symbols associated with a place to create new structural type info associated
with that symbol; with the hint that "|" means "or" and that all words starting with capitals
are symbols wich we associate witch structure and meaning, and that everything starting with a
lowercase character is a (type-) parameter, have a look at the definiton of the datatype definitons in the follwoing;


-}

data Point2D = Point2D Double Double deriving (Show)

{-

this defines a data type wich
contains to floats: a 2-D point...
before we go on, let's define another data type,
but this time one that is
parameterised with another type.
Comparable with C++ templates:


-}

data Triangle p = Triangle p p p deriving (Show)

{-

now we create a simple alias
for 2D triangles (typedef in C++):


-}

type Triangle2D = Triangle Point2D

{-

Confused now? good, we can move on...

Our Point2Ds can be created and read.
Their contents (the two floats) are
readonly. This of course doesn't bother
us at all, it turns out in the long run
to be a really nice feature
concerning readability of code.

Assume the following function that generates
a "circle" made of n points with a radius of r:


-}

generate_circle r n = [Point2D (calc sin i) (calc cos i) | i <- [0 .. (n - 1)]]
    where calc op i =  r * op ((i/n) * 2 * pi)

{-

which looks like this in Java:


class Point2d {
  private final double x;
  private final double y;

  public Point2d(double x, double y) {
    this.x = x;
    this.y = y;
  }
  /* ... some getters... */
}

public final class GenerateCircle {
   
   final Point2d[] points;
   final double r;
   final int n;

   public GenerateCircle(double r, int n) {
     points=new Point2d[n];
     this.r = r;
     this.n = n;
     for ( int i = 0; i < n; ++i) {
       points[i] = new Point2d(calc_sin(i), calc_cos(i));
     }
   }
   private float calc_sin(int i) {
     return r * Math.sin((double)i/n * 2.0 * Math.PI);
   }
   private float calc_cos(int i) {
     return r * Math.cos((double)i/n * 2.0 * Math.PI);
   }
   /* ... some getters ... */
}

pattern matching and guards

Pattern matching is syntactic sugar that frees one
from writing complicated if and switch constructs.
Combined with algebraic data types, a feature that java lacks for sure -
it is, as we have seen above, a way to simulate generic methods.

Another useful construct is the function guard;
let's look at a practical example:
the programmer of the display function
may use a simple constraints(a guard) to protect
the precious display function:
(the guard is the boolean expression
between the "|" and the "=")
Now if in that example x or y is less than 0 a runtime exception
is thrown, with detailed information where and why the error was caused.(Try it already!)


-}

display_list primitives = [display p | p <- primitives]
    where display (Point2D x y)
              | x >= 0  &&  y >= 0     = show (Point2D x y)

{-

All we do now is add a super type for primitives
and pimp our "display_list function a little to make
use of pattern matching in conjunction with
algebraic data types(see below):


-}

data Primitive = Point Point2D | Tri Triangle2D

display_primitives :: [Primitive] -> [String]
display_primitives primitives = [display p | p <- primitives]
    where
      display (Point (Point2D x y)) 
          | x >= 0 && y >= 0 = show (Point2D x y)
      display (Tri (Triangle p1 p2 p3)) 
          = show (Triangle p1 p2 p3)

{-

higher order functions, lambdas, currying and sections

When it comes to functions, lambdas and closures haskell really shines.
In haskell everything is done with functions. Let's have
a look at a small example.
Note that this example also makes heavy use of algebraic datatypes and pattern
matching.


-}

data MyTree t = Leaf t | Node [MyTree t]

{-

In Java this would look like this:


public interface MyTree<T> {
    public class Leaf<S> implements MyTree<S> {
 public S data;
    }
    public class Node<S> implements MyTree<S> {
 public MyTree<S> childs;
    }
}

This results in a tree with data in the leafs. Let's define a matches function,
that returns a list of "ts" that match a user defined predicate(or matcher function):


-}

matches matcher (Leaf t)       = if matcher t then [t] else []
matches matcher (Node childs)  = [e | child <- childs,  e <- matches matcher child] 

{-

well that's it! The first clause of the function "matches" is applied only to Leafs
and the second clause uses list comprehension to call "matches" recursivly
for every child node.

In java is considerably harder to write (and to read).

Now let's leave this planet, and let's head off into a galaxy far far away...
Lets write a matcher that checks that the first letter is a capital "A", but let's
do this in two steps, lets first create a "startsWith" function that you should be
familiar with from other languages, and after the a function using the first one,
that checks for the capital "A".


-}
startsWith str = (( == str) . (take (length str)))

{-

this can actually be translated to english:
"combine two functions: (this is the "." operator)

A function that compares something for equality with str, this is "(== str)".
I used a fancy haskell feature here... (==str) is actually function call
to the function "==" which needs to arguments and returns True or False.
We gave the function only one argument "str". Of course the "==" function
cannot give us a Boolean value for that! But instead it gives us a new function,
a closure, that takes only one argument and returns a Bool. Isn't that cool?!
I mean once you get used to that, it's really readable and you will never want
to go back!

A function that returns a sublist of a list containing only the the first
"(length str)" elements: "(take (length str))"
BTW, a string in haskell is a list of characters, and "length" returns the number
of elements in a list.

Observe that startsWith takes only one argument not two! You may wonder how startsWith
can work, because it needs the string to search for and a string to search in.

Recall the weired (== str) construct. What happend here happens again: we created a new
anonymous function by calling a function named "==" with not enough arguments, btw.
this is called currying(- invented by the logician "Haskell Brooks Curry")
We also called "take" wich actually needs two arguments with only one argument
(the string length). The result is therefore a function the takes a string and returns
the desired sub-string with the same length that "str" has.
Now the combine operator (".") combines the two functions that each take one argument
and creates a new one such that the new function takes the input string for (take ...)
and returns the result of "(==str)" called with the result of "(take ...)";

Let's forget about (==str) and (take...) for a while and let's look at the definition of
".":


  (f . g) x = f(g(x))

this might look familiar...
Now it should become clearer what the result of calling the startsWith function with
ONE parameter is: a new function that takes a string and returns a Bool indicating
wether or not the string given to that anonymous function starts with the string!

Once a programmer has learned very few core concepts about the function handling,
haskell source code is very readable, although it is often less terse than java code.

Also note that our startsWith function is perfectly generic, it can be applied to
ANY type of lists not just strings wich happen to be a synonym for lists of "Char"!

Now I do not want to write down equivilant code for that in java, I think it is
possible. Also note that I do not want to judge the qualities of languages,
I just want to study them.

Ok, back to topic, let's create a test function that roughly corresponds to the one in
the original blogpost.

Remeber that we wanted to define a second function in terms of the first function,
that checks if a string starts with a capital "A"?
Here we use currying again, and simlpy and clearly write:


-}
startsWithA = startsWith "A"

keywordTree = Node [ Node [ Leaf "Hallo"], Leaf "lieber", Leaf "Allerwertester", Node [Node [], Node [Leaf "Wie"], Leaf "gehts"], Leaf "dir"]

test_matches_1 = matches startsWithA keywordTree

{-

oh, let's not forget to introduce a lambda!
the greek symbol for a small lambda actually looks alot like the "\" (backslash) charakter,
so in haskell a lambda is defined like this:


\x  -> x + 2

in python:


lambda x: x + 2

another way in haskell:


(2 +)

A lambda expression with two parameters can be written in haskell like this:


\x y -> x + y

or simply:

(+)

another way to write (==str) using a lambda:


\x -> x == str

Ok, back to the tree example,
let's use a lambda expression as a parameter for "matches"
to filter all words shorter than 5 characters.
The then the complete expression looks like this:

  
-}

test_matches_2 = matches (\x -> length x <= 5) keywordTree

{-

of course we can assign the lamda expression to a name, and use that instead.


-}

shorter_than_5_chars = \x -> length x <=5
test_matches_3 = matches shorter_than_5_chars keywordTree

{-

This can of course be written with haskells usual function definition syntax:


-}

shorter_than_4_chars x = length x <= 4
test_matches_4 = matches shorter_than_4_chars keywordTree

{-

And even more compact using functional compisition and sections:


-}

shorter_than_6_chars = (<=6) . length
test_matches_5 = matches shorter_than_6_chars keywordTree

{-

shorter_that_6_chars is written in point-free style, that means
that in contrast to the previous definitons we didn't explicitly name
the argument wupped around in the function, instead we just combined
the the functions.
This is very smilar to the pipe syntax in the bash:


 $ cat /proc/cpuinfo | grep bogo | awk '{print $3}' | sort -n

Here too no variable is mentioned, that actually contains the current line
that is passed around.
A functions stdin is its parameter and a functions stdout is its return value.
That's also why it is so important in haskell to have currying automatically
everywhere, because it allows me to use a function with more than one
parameters as a function with one parameter wich returns a new function,
wich takes one parameter and returns a new functions wich takes one parameter ... etc
until final we get the actual result of the computation.

Factories?

Writing factories in haskell might by now seem not very interesting; still
let's write some RPC class definitons in haskell:


-}

data RPC = XMLRPC String | JSONRPC String

data RPCResult = Void | Str String | Strs [String] | Numbers [Int] -- define some results here...
                 deriving (Show)
                          
callRemote :: RPC -> String -> [String] -> RPCResult
callRemote (XMLRPC conn) function args =
    Str ("nyi, xmlrpc to "++ conn ++" func: " ++ function ++ " args: " ++ (show args))
callRemote (JSONRPC conn) function args = 
    Str ("nyi, jsonrpc to "++ conn ++" func: " ++ function ++ " args: " ++ (show args))


{-

Here is a little testfunction so you know how to use this;
it will call the jsonrpc service "helloworld" at "http://..." with the arguments 1,2


-}

test_json_rpc = callRemote (JSONRPC "http://test.org/service") "helloworld" ["1", "2"]

--

now to a the factory:



rpc_factory ::  String -> String -> RPC 
rpc_factory impl arg = case impl of
                         "JSON" -> JSONRPC arg
                         "XML"  -> XMLRPC arg

test_rpc_factory name = callRemote conn "trigger" []
    where conn = rpc_factory name "http://alarm.org/sirene"
{-

Call the test_rpc_factory function with either "XML" or "JSON" from the
ghci shell.

A factory also makes sense when one wants to extend the programm at runtime.
This can be done in haskell. Code can be dynamically loaded and recompiled
in running haskell programms (see "hs-plugin"), with type checking and dependency
resolution.

It is possible to create a complete OO-Class infrastructure in haskell,
similar to what exists in python, java and CLOS.

Lesser need for DI and friends

A nice application of factories is dependency injection.
This extends the idea of factories, it allows programmers to wire all class
instance dependencies and configuration values in one function in a declarative way.
In powerfull functional languages this might be pointless in situation where this approach makes
perfect sense in programs written in python or java, as the means of functional abstraction
and combination, especially when used in combination with a powerfull type system, and pattern
matching, render dependency injection frameworks simply useless - if the whole point
of the dependency injection was merely the declarative wireing of class dependencies and
configuration and not the ability to change all that at runtime.
On the other hand, in systems like the erlang runtime complicated mechanisms exist to actually
exchange code and the the dependencies of the code at runtime,
while maintaining the serveral versions of the same code when it is still required,
with automatically restarting services in the correct order when necessary, etc.

Well I hope I have shown, that haskell can actually be fun to work with, and that
diffrent approaches in the design of programming languages are always fun to look at.

That's all folks

The original blog post author compared python with java to show the things he likes in python and
he misses in java.
This comparison has shown how similar phyton and java actually are when compared with haskell ;)
My relation to haskell and java is similar to the blogpost authors relation to python and java,
I think that the author should definitely have a look at haskell, for the
relation to haskell and python might just develop to be of a similar nature,
and the learning experience might also be pretty enlightening.

-}

NumberCheck in haskell

2008-05-27T14:31:00.003+02:00


import System.Environment
import Data.Char

main = do
   arg:_ <- getArgs
   putStrLn (arg ++ " is " ++ (result arg))
   where result arg = if check arg then "correct" else "incorrect"
         check arg = dotOrDigit `all` arg && oneOrZeroDots arg
         dotOrDigit = (`elem` ['0'..'9'] ++ ['.'])
         oneOrZeroDots = (<=1) . length . (filter ('.'==))

logs display, little experiment

2008-05-21T02:47:00.016+02:00

this code ...


module LogDiffMarker where

type ReferenceWords = [String] 
type Lines = [Line]
type Line = String

mark_diffrent_words :: (ReferenceWords, Lines) -> Line -> (ReferenceWords, Lines)
mark_diffrent_words (ref,i) line = (next_ref, i ++ [unwords line_with_em]) 
    where (line_with_em, next_ref) = mark_diffrences (words line) ref ([],[])       
          mark_diffrences l1 [] (line_acc, ref_acc) = (line_acc ++ ["<b>"] ++ l1 ++ ["</b>"], ref_acc ++ l1)
          mark_diffrences [] r (line_acc, ref_acc) = (line_acc, ref_acc)
          mark_diffrences (h1:t1) (h2:t2) (line_acc, ref_acc)
                  | h1 == h2  = mark_diffrences t1 t2 (line_acc ++ [h1] ,ref_acc ++ [h2]) 
                  | otherwise = mark_diffrences t1 t2 (line_acc ++ ["<b>" ++ h1 ++ "</b>"],ref_acc ++ [h1])

mark_diffrent_lines :: Lines -> Lines
mark_diffrent_lines = (["<pre>"]++) . (++["</pre>"]) . snd . (foldl mark_diffrent_words ([], []))
  
main = interact (unlines . mark_diffrent_lines . lines)

...is a proof of concept of a highlighter algorithm for a logdisplayer that - if proofed useful - will be rewritten in javascript/html

from:


May 10 05:52:19 ubuntu syslogd 1.5.0#1ubuntu1: restart.
May 10 06:22:02 ubuntu -- MARK --
May 10 06:42:02 ubuntu -- MARK --
May 10 06:51:49 ubuntu kernel: [ 2145.672201] nautilus[6101]: segfault at e1000020 eip b773f2d6 esp bfe4d9d0 error 5
May 10 06:51:51 ubuntu kernel: [ 2147.588620] gdm[5658]: segfault at 10c03f90 eip b7801635 esp bf8100e0 error 4
May 10 06:51:53 ubuntu kernel: [ 2149.171081] ip6_tables: (C) 2000-2006 Netfilter Core Team
May 10 06:51:54 ubuntu exiting on signal 15
May 12 19:07:04 ubuntu syslogd 1.5.0#1ubuntu1: restart.
May 12 19:07:04 ubuntu kernel: Inspecting /boot/System.map-2.6.24-16-generic
May 12 19:07:04 ubuntu kernel: Loaded 27704 symbols from /boot/System.map-2.6.24-16-generic.
May 12 19:07:04 ubuntu kernel: Symbols match kernel version 2.6.24.
May 12 19:07:05 ubuntu kernel: Loaded 32155 symbols from 83 modules.
May 12 19:07:05 ubuntu kernel: [    0.000000] Linux version 2.6.24-16-generic (buildd@palmer) (gcc version 4.2.3 (Ubuntu 4.2.3
May 12 19:07:05 ubuntu kernel: [    0.000000] BIOS-provided physical RAM map:
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 0000000000000000 - 000000000009f800 (usable)
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 000000000009f800 - 00000000000a0000 (reserved)
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 00000000000f0000 - 0000000000100000 (reserved)
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 0000000000100000 - 000000007fff0000 (usable)
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 000000007fff0000 - 000000007fff3000 (ACPI NVS)
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 000000007fff3000 - 0000000080000000 (ACPI data)
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 00000000d0000000 - 00000000e0000000 (reserved)
May 12 19:07:05 ubuntu kernel: [    0.000000]  BIOS-e820: 00000000fec00000 - 0000000100000000 (reserved)
May 12 19:07:05 ubuntu kernel: [    0.000000] 1151MB HIGHMEM available.
May 12 19:07:05 ubuntu kernel: [    0.000000] 896MB LOWMEM available.
May 12 19:07:05 ubuntu kernel: [    0.000000] found SMP MP-table at 000f52c0
May 12 19:07:05 ubuntu kernel: [    0.000000] Zone PFN ranges:
May 12 19:07:05 ubuntu kernel: [    0.000000]   DMA             0 ->     4096
May 12 19:07:05 ubuntu kernel: [    0.000000]   Normal       4096 ->   229376
May 12 19:07:05 ubuntu kernel: [    0.000000]   HighMem    229376 ->   524272
May 12 19:07:05 ubuntu kernel: [    0.000000] Movable zone start PFN for each node
May 12 19:07:05 ubuntu kernel: [    0.000000] early_node_map[1] active PFN ranges
May 12 19:07:05 ubuntu kernel: [    0.000000]     0:        0 ->   524272
May 12 19:07:05 ubuntu kernel: [    0.000000] DMI 2.3 present.
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: RSDP signature @ 0xC00F6C50 checksum 0
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: RSDP 000F6C50, 0014 (r0 Nvidia)
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: RSDT 7FFF3000, 0030 (r1 Nvidia AWRDACPI 42302E31 AWRD  1010101)
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: FACP 7FFF3040, 0074 (r1 Nvidia AWRDACPI 42302E31 AWRD  1010101)
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: DSDT 7FFF30C0, 4BF2 (r1 NVIDIA AWRDACPI     1000 MSFT  100000C)
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: FACS 7FFF0000, 0040
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: MCFG 7FFF7D40, 003C (r1 Nvidia AWRDACPI 42302E31 AWRD  1010101)
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: APIC 7FFF7CC0, 007C (r1 Nvidia AWRDACPI 42302E31 AWRD  1010101)
May 12 19:07:05 ubuntu kernel: [    0.000000] Nvidia board detected. Ignoring ACPI timer override.
May 12 19:07:05 ubuntu kernel: [    0.000000] If you got timer trouble try acpi_use_timer_override
May 12 19:07:05 ubuntu kernel: [    0.000000] ACPI: PM-Timer IO Port: 0x1008


May 10 05:52:19 ubuntu syslogd 1.5.0#1ubuntu1: restart.
May 10 06:22:02 ubuntu -- MARK --
May 10 06:42:02 ubuntu -- MARK --
May 10 06:51:49 ubuntu kernel: [ 2145.672201] nautilus[6101]: segfault at e1000020 eip b773f2d6 esp bfe4d9d0 error 5
May 10 06:51:51 ubuntu kernel: [ 2147.588620] gdm[5658]: segfault at 10c03f90 eip b7801635 esp bf8100e0 error 4
May 10 06:51:53 ubuntu kernel: [ 2149.171081] ip6_tables: (C) 2000-2006 Netfilter Core Team
May 10 06:51:54 ubuntu exiting on signal 15
May 12 19:07:04 ubuntu syslogd 1.5.0#1ubuntu1: restart.
May 12 19:07:04 ubuntu kernel: Inspecting /boot/System.map-2.6.24-16-generic
May 12 19:07:04 ubuntu kernel: Loaded 27704 symbols from /boot/System.map-2.6.24-16-generic.
May 12 19:07:04 ubuntu kernel: Symbols match kernel version 2.6.24.
May 12 19:07:05 ubuntu kernel: Loaded 32155 symbols from 83 modules.
May 12 19:07:05 ubuntu kernel: [ 0.000000] Linux version 2.6.24-16-generic (buildd@palmer) (gcc version 4.2.3 (Ubuntu 4.2.3-2ubuntu7)) #1 SMP Thu Apr 10 13:23:42 UTC 2008 (Ubuntu 2.6.24-16.30-generic)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-provided physical RAM map:
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 0000000000000000 - 000000000009f800 (usable)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 000000000009f800 - 00000000000a0000 (reserved)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 00000000000f0000 - 0000000000100000 (reserved)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 0000000000100000 - 000000007fff0000 (usable)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 000000007fff0000 - 000000007fff3000 (ACPI NVS)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 000000007fff3000 - 0000000080000000 (ACPI data)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 00000000d0000000 - 00000000e0000000 (reserved)
May 12 19:07:05 ubuntu kernel: [ 0.000000] BIOS-e820: 00000000fec00000 - 0000000100000000 (reserved)
May 12 19:07:05 ubuntu kernel: [ 0.000000] 1151MB HIGHMEM available.
May 12 19:07:05 ubuntu kernel: [ 0.000000] 896MB LOWMEM available.
May 12 19:07:05 ubuntu kernel: [ 0.000000] found SMP MP-table at 000f52c0
May 12 19:07:05 ubuntu kernel: [ 0.000000] Zone PFN ranges:
May 12 19:07:05 ubuntu kernel: [ 0.000000] DMA 0 -> 4096
May 12 19:07:05 ubuntu kernel: [ 0.000000] Normal 4096 -> 229376
May 12 19:07:05 ubuntu kernel: [ 0.000000] HighMem 229376 -> 524272
May 12 19:07:05 ubuntu kernel: [ 0.000000] Movable zone start PFN for each node
May 12 19:07:05 ubuntu kernel: [ 0.000000] early_node_map[1] active PFN ranges
May 12 19:07:05 ubuntu kernel: [ 0.000000] 0: 0 -> 524272
May 12 19:07:05 ubuntu kernel: [ 0.000000] DMI 2.3 present.
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: RSDP signature @ 0xC00F6C50 checksum 0
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: RSDP 000F6C50, 0014 (r0 Nvidia)
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: RSDT 7FFF3000, 0030 (r1 Nvidia AWRDACPI 42302E31 AWRD 1010101)
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: FACP 7FFF3040, 0074 (r1 Nvidia AWRDACPI 42302E31 AWRD 1010101)
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: DSDT 7FFF30C0, 4BF2 (r1 NVIDIA AWRDACPI 1000 MSFT 100000C)
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: FACS 7FFF0000, 0040
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: MCFG 7FFF7D40, 003C (r1 Nvidia AWRDACPI 42302E31 AWRD 1010101)
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: APIC 7FFF7CC0, 007C (r1 Nvidia AWRDACPI 42302E31 AWRD 1010101)
May 12 19:07:05 ubuntu kernel: [ 0.000000] Nvidia board detected. Ignoring ACPI timer override.
May 12 19:07:05 ubuntu kernel: [ 0.000000] If you got timer trouble try acpi_use_timer_override
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: PM-Timer IO Port: 0x1008
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: LAPIC (acpi_id[0x00] lapic_id[0x00] enabled)
May 12 19:07:05 ubuntu kernel: [ 0.000000] Processor #0 15:3 APIC version 16
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: LAPIC (acpi_id[0x01] lapic_id[0x01] enabled)
May 12 19:07:05 ubuntu kernel: [ 0.000000] Processor #1 15:3 APIC version 16
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x00] dfl dfl lint[0x1])
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x01] dfl dfl lint[0x1])
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: IOAPIC (id[0x02] address[0xfec00000] gsi_base[0])
May 12 19:07:05 ubuntu kernel: [ 0.000000] IOAPIC[0]: apic_id 2, version 17, address 0xfec00000, GSI 0-23
May 12 19:07:05 ubuntu kernel: [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl)

functional music, honorable mention of new composer C.W. Boese

2008-04-30T01:38:00.001+02:00

just after the previous post a talented composer (Boese) used the small framework for functional music in haskell for one of his compisitions. His work balances harmony and disharmony in an unbalanced way and thereby balances the unbalancing and balancing forces driving the excellent piece of modern algorithmic music. with his silent permission the source as well the interpretation is attached to this post.

Here's the interpretation using an artifical Clarinet: play.

Here's the source:


boeseboese = Rest (2/4) :+: (hochlauf (-2) 3 boese) :=: (hochlauf (2) 3 boese) :+: boese
boese = rpt 3 freak :=: rpt 3 ghoul :=: rpt 3 funk
grund = (Note (Cis,5) 1)
freak = rptm (Trans (round (abs (duration ghoul)))) 3 funk
ghoul = akkord grund 0
funk = Trans terz grund :=: rptm (Trans quinte) 4 ghoul

just append that to the previous program and adapt the main function.

Maybe it's also worth mentioning, that this was the first piece of haskell code written by him.
Haskell syntax helps to create frameworks with very little effort, that reassemble DSLs. In this case parts of the DSL for functional music from the School Of Expression was used to aid composers in creating algorithmic music without the syntactic burdens of a low-level language like (Ihh.. pfui... bahh) "java", that lack many, even basic features, like being NullPointer free, pattern matching, currying, higher order functions, type inference, laziness, ...etc.

Learning Haskell, functional music

2008-04-29T19:11:00.000+02:00

As you might have realized, I started to learn Haskell. One of the most fun things to do in any programming language is creating some kind of audible side effects with a program.
Already back in the days when I started programming, I always played around with audio when toying around with a new language.

I have found a wonderful set of lecture slides about haskell and multimedia programming, called school of expression. Inspired by the slides about functional music I implemented a little song. Ahh ... and yes it is intended to sound slightly strange.

I used the synthesis toolkit to transform the music to real noise, simply by piping skini message to std-out.

I used this command line to achieve the results audible in the table:


sven@hhi1214a:~/Mukke$ ghc -o test1 test1.hs &&  ./test1 | stk-demo Plucked -n 16 -or -ip

Sound samples:

Plucked	play
Clarinet	play
Whistle(attention very crazy!)	play

As always the source...

stueck = anfang :+: mitte :+: ende

anfang = groovy :+: (Trans (-5) trickie)
mitte = seq_overlap (1/3) mitte1 mitte2
mitte1 = (3/4) `schneller`  (Trans (-2) groovy) 
mitte2 = (3/4) `schneller` groovy
ende = Rest (1/4) :+: (moll_akkord (Note (A,4) 1))

groovy = dumschingbadumschingsching 3 (2/3) -- fast schon swing artiger rythmischer versatz
trickie = dumschingbadumschingsching 2 (3/4)

blim_sching af = ((Note (A,3) (1/4)) :+: (af (Note (A,4) (1/4))))
dumdideldum af = quinten_hochlauf 4 (rpt 2 $ blim_sching af) -- 4 klingt leicht schief
dumschingbadumschingsching r versatz = interleave r versatz (dumdideldum moll_akkord) (Trans 3 (dumdideldum dur_akkord))

main :: IO ()
main = do
mapM_ putStrLn $ music_to_skini stueck 33

-- functional music composition
hochlauf tr n m = rep (Trans quinte) (delay (duration m)) n m
quinten_hochlauf = hochlauf quinte
interleave n dist m1 m2 = (rpt n m1) :=:  (Rest dist :+: (rpt n m2))
schneller spdup m =  (Tempo ((duration m)*(spdup)) m)

akkord grundton moll_dur = grundton :=: (Trans (3 + moll_dur) grundton) :=: (Trans 7 grundton)
moll_akkord grundton = akkord grundton 0
dur_akkord grundton = akkord grundton 1

terz    = 3
gr_terz = 4
quarte  = 5
quinte  = 7

seq_overlap overlap m1 m2 = m1 :=: (delay ((duration m2) - overlap) m2)

rpt 0 m = Rest 0
rpt n m = m :+: rpt (n-1) m

rptm f 0 m = Rest 0
rptm f n m = m :+: rptm f (n - 1) (f m)

rep f g 0 m = Rest 0
rep f g n m = m :=: g (rep f g (n-1) (f m))

--  functional music basics, based on the school of expression lecture slides
data Music = Note Pitch Dur
| Rest Dur
| Music :+: Music
| Music :=: Music
| Tempo Dur Music
| Trans Int Music
| Instr Int Music
| Control ControlMessage Music
deriving (Show, Eq)

type Dur = Rational

type Pitch = (Tone, Octave)
data Tone = C | Cis | D | Dis | E | F | Fis | G | Gis | A | B | H
deriving (Show, Eq)
type Octave = Int

type ControlMessage = (Int, Int)

-- absolute pitches
type AbsPitch = Int

trans :: Int -> Pitch -> Pitch
trans i p = pitch (absPitch p + i)

pitch :: AbsPitch -> Pitch
pitch p = ([C, Cis, D, Dis, E, F, Fis, G, Gis, A, B, H] !! mod p 12, p `quot` 12)

absPitch :: Pitch -> AbsPitch
absPitch (n, o) = (o * 12) + (case n of C -> 0; Cis -> 1; D -> 2; Dis -> 3; E -> 4; F -> 5; Fis -> 6; G -> 7; Gis -> 8; A -> 9; B -> 10; H -> 11)

-- delay
delay :: Dur -> Music -> Music
delay d = ((Rest d) :+:)

-- absolute durations
abs_dur :: BeatPM -> Dur -> AbsDur
abs_dur bpm d = (fromRational d) / (bpm / (60.0))

type BeatPM = Float
type AbsDur = Float

-- calculate the duration of a piece of music
duration :: Music -> Dur
duration m = case m of
Rest d -> d
Note _ d -> d
m1 :+: m2 -> duration m1 + duration m2
m1 :=: m2 -> max (duration m1) (duration m2)
Tempo d _ -> d
Trans _ m1 -> duration m1
Instr _ m1 -> duration m1
Control _ m1 -> duration m1

-- convert to a simple event stream of musical events with absolute values
-- that soley consist of NoteOn and NoteOff events with midi notes and timestamps
data MusicEvent = MusicEv MusicEventType AbsPitch AbsDur
deriving (Show, Eq)

data MusicEventType = NoteOn | NoteOff
deriving (Show, Eq)

to_event_stream :: BeatPM -> Music -> AbsDur -> (AbsDur, [MusicEvent])
to_event_stream bpm um start_time =
    case m of
Note p d ->
 let dur = start_time + (abs_dur bpm d)
 in (dur, [(MusicEv NoteOn (absPitch p) start_time), (MusicEv NoteOff (absPitch p) dur)])

Rest d ->
 (start_time  + (abs_dur bpm d), [])

Tempo d m1 ->
 to_event_stream (bpm * (fromRational (duration m1)) * 1.0/(fromRational d)) m1 start_time

m1 :+: m2 ->
 (total_dur,  evt_str1 ++ evt_str2)
 where (st1, evt_str1) = to_event_stream bpm m1 start_time
       (total_dur, evt_str2) = to_event_stream bpm m2 st1

m1 :=: m2 ->
 (max dur1 dur2, merge evt_str1 evt_str2)
 where (dur1, evt_str1) = to_event_stream bpm m1 start_time
       (dur2, evt_str2) = to_event_stream bpm m2 start_time

_ -> (start_time, [])

    where
m = transpose_all um 0
transpose_all :: Music -> Int -> Music
transpose_all m tr = case m of
 Trans tr2 m1 -> transpose_all m1 (tr + tr2)
 Note p d -> Note (trans tr p) d
 m1 :+: m2 -> (transpose_all m1 tr) :+: (transpose_all m2 tr)
 m1 :=: m2 -> (transpose_all m1 tr) :=: (transpose_all m2 tr)
 other -> other
merge :: [MusicEvent] -> [MusicEvent] -> [MusicEvent]
merge l1 l2 = mergea l1 l2 []
mergea :: [MusicEvent] -> [MusicEvent] -> [MusicEvent] -> [MusicEvent]
mergea [] l2 acc = acc ++ l2
mergea l1 [] acc = acc ++ l1
mergea l1@(e1@(MusicEv _ _ dur1):r1) l2@(e2@(MusicEv _ _ dur2):r2) acc
 | dur1 <=  dur2 = mergea r1 l2 (acc ++ [e1])      | dur1 >   dur2 = mergea l1 r2 (acc ++ [e2])  

-- convert to skinni
{-
    
NoteOn delay channel midi-note volume
NoteOff delay channel midi-note volume
time is always the time to wait after the last event
arg1 is the midi note number
arg2 is the volume
-}
to_skini :: [MusicEvent] -> [[Char]]
to_skini event_stream = skini_stream
where (time_acc, skini_stream) = foldl make_skini (0.0, []) event_stream
 make_skini :: (AbsDur, [[Char]]) -> MusicEvent -> (AbsDur, [[Char]])
 make_skini (total_time, other_skini) (MusicEv mtype pitch ev_time)  =
  (ev_time, other_skini ++ [(show mtype) ++ "   " ++ (show (ev_time - total_time)) ++ "   1   " ++ (show pitch) ++ "   127.0"])

music_to_skini :: Music -> BeatPM -> [[Char]]
music_to_skini m bpm = to_skini event_stream 
where (_, event_stream) = to_event_stream bpm m 0.0

Haskell Thread Ring Benchmark

2008-04-11T03:59:00.000+02:00

Not as fast as the erlang version coming soon:



import Control.Monad
import Control.Concurrent
import System.Environment
import System.CPUTime

fork_ring_elem prev_mvar _ = do
  next_mvar <- newEmptyMVar
  forkIO (ring_elem prev_mvar next_mvar)
  return next_mvar

ring_elem :: MVar Int -> MVar Int -> IO ()
ring_elem prev_mv next_mv = run
  where run = do
          token <- takeMVar prev_mv
          putMVar next_mv (token - 1)         
          when ( token > 0 ) run

first_ring_elem :: MVar Int -> MVar Int -> IO ()
first_ring_elem prev_mv next_mv = run
  where run = do
          token <- takeMVar prev_mv
          putMVar next_mv (token - 1)         
          putStrLn "."
          when ( token > 0 ) run

main = do
  (procsArg:roundsArg:_) <- getArgs
  first_mvar <- newMVar ((read procsArg) * (read roundsArg))
  t1 <- getCPUTime
  last_mvar <- foldM fork_ring_elem first_mvar [2..(read procsArg)]
  t2 <- getCPUTime
  putStrLn ("forked processes in " ++ (show (t2 - t1)) ++ " ps")
  first_ring_elem last_mvar first_mvar
  t3 <- getCPUTime
  putStrLn "\n***finished***"
  putStrLn ("total time: " ++ (show (t3 - t1)) ++ " ps")

coping emacs #1

2008-03-08T16:50:00.000+01:00

After having written a lot of erlang code with emacs(uhhm ... no, erlide, the erlang eclipse plugin, is not yet a viable alternative...), I decided to start (back-)porting eclipse features to emacs. Yeahhhh! I am now among those 1337 |-|4><025 that have their own ".emacs" in ~.

Well one feature, that I can't live without, is moving the current line with Alt - up/down, this is really usefull together with ~~another~~the other feature: duplicating the current line(Ctrl-Alt-up/down).

Below is the elisp code that provides these features and binds them to the keys these are bound to in eclipse. Note: In contrast to the eclipse version of this feature, this implementation does not(yet) work with regions, but with lines only.

Ok, put this in your ~/.emacs


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Written by Sven Heyll in 2008
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun sh-wind-col (thunk)
  (let ((col (- (point) (line-beginning-position))))
    (apply thunk '())
    (beginning-of-line)
    (forward-char col)))

(defun sh-with-current-line (func)
  (let ((cline (buffer-substring (line-beginning-position) (line-end-position))))
    (apply func `(,cline))))

(defun sh-dup-line-down ()
  (interactive)
  (sh-wind-col
   (lambda ()
     (sh-with-current-line
      (lambda (cline)
 (end-of-line)
 (insert ?\n)
 (insert cline))))))

(defun sh-dup-line-up ()
  (interactive)
  (sh-wind-col
   (lambda ()
     (sh-with-current-line
      (lambda (cline)
 (beginning-of-line)
 (insert cline)
 (insert ?\n)
 (forward-line -1))))))

(global-set-key [C-M-down] 'sh-dup-line-down)
(global-set-key [C-M-up]   'sh-dup-line-up)
   
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun sh-move-line (dir)
  (defun extract-a-line (dir)
    (let ((line-start (line-beginning-position (+ 1 dir)))
   (line-end   (line-end-position (+ 1 dir))))
      (setq res (delete-and-extract-region line-start line-end))
      (delete-region line-start (+ 1 line-start))
      res))
  (if (not 
       (or 
 (and (< dir 0) (= (line-beginning-position) (point-min)))
 (and (> dir 0) (= (line-end-position) (- (point-max) 1)))))
      (let
   ((col (- (point) (line-beginning-position)))
    (line (extract-a-line dir)))
 (if (< dir 0)
     (progn
       (end-of-line)
       (insert ?\n)
       (insert line))
   (progn 
     (beginning-of-line)
     (insert line)
     (insert ?\n)))
 (beginning-of-line (truncate (+ 0.5 (* 0.5 dir))))
 (forward-char col))))
  
(defun sh-line-down ()
  (interactive)
  (sh-move-line 1))

(defun sh-line-up ()
  (interactive)
  (sh-move-line -1))

(global-set-key [M-down] 'sh-line-down)
(global-set-key [M-up] 'sh-line-up)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Visualisation of DNA

2008-02-16T22:28:00.000+01:00

After some attention has been caought by the wonderfull Rainbow DNA project, I have decided to join the club! Here is a very simplistic, far more useless way of visualising DNA: turtle graphics.
I really cannot put up a website with comlete renderings of the DNA using turtle graphics, but I uploaded two sample images to my flikr account. I wanted to find out if turtle graphics could reveal diffrent sets of patterns as those perceivable with a color plot of basepairs.

Attached is source code so you can see what the program does. You can also reuse the part that proceses the contents of "gbk" files containing genome data.

The code is just a hack done at night while I was waiting in a starbucks for a friend to pick me up, so if you think this code is a mess - you earned your degree, I was just curios after I found out about the rainbow dna project.

Well the idea of the program is very simple:
1. Initialise the turtle to be in center of the screen
2. read the next basepair, for each base encountered look up the turtle rotation
3. rotate the turtle
4. draw 5 pixels
5. goto step 2 until finished with a gene

So here are the results, not surprisingly very unspectacular. If you want a good representation for the contents of the human genome, well ... look into a mirror. All other reps. just look ridiculous in comparison.

I think it's funny, that one could argue that the dna seems to be like a multi-quine: not only that it conatins the code that creates organisms to reproduce itself through regular biological reproduction, it also encodes a brain with the ability to create turtle renderings of itself...

In the following image rendering the following rules were applied. Whenever an "a" (as of a, c, t, g) is encountered turn the turle by -180 degree, on "c" -60 degrees, "t" 60 deg and "g" 180 deg.

In the next rendering the following rules apply. Whenever an "a" turns the turle by 23 degree, on "c" 42 degrees, "t" 128 deg and "g" 15 deg.

Ok now here is the code.
You might want to get the gbk files. Have a look at my delicious account, I have stored a link to an ftp server where a gbk file for every chromosome of the human genome can be found.

For my experiments I used parts of the X chromosome.


(require (lib "turtles.ss" "graphics"))


(load "boyer-moore.scm")
(load "lazy-streams.scm")
(load "list-utils.scm")

;; read a line
(define LS #\newline)
                          
(define (read-line port) 
  (let loop ((line '())
             (c (read-char port)))
    (if (eof-object? c)
        (reverse (cons c line))
        (if (eqv? c LS)
            (reverse line)
            (loop (cons c line) (read-char port)) ) )))

(define (lazy-line-stream port)
  (define current-line (read-line port))
  (define result-stream 
    (cons-lazy-stream current-line (lazy-line-stream port)))
  (if (eof-object? (car current-line))
      the-empty-lazy-stream
      result-stream))

(define (filter-bases char-list)
  (filter 
   (lambda (c) (or (eqv? c #\a) (eqv? c #\c) (eqv? c #\g) (eqv? c #\t))) 
   char-list))  

(define (process-gbk port info-block-func base-pair-func post-draw)
  (define (loop-base-pairs line-stream)
    (if (empty-lazy-stream? line-stream) 
        (display "stream exhausted(while basepair parsing).")
        (if (and (eqv? (car (lazy-head line-stream)) #\/) (eqv? (cadr (lazy-head line-stream)) #\/))
            (begin
              (post-draw)
              (loop-header (lazy-tail line-stream) '())) 
            (begin          
              (base-pair-func (filter-bases (lazy-head line-stream))) 
              (loop-base-pairs (lazy-tail line-stream))))))
  (define (loop-header line-stream info-block-A)
    (if (empty-lazy-stream? line-stream) 
        (begin (newline)
               (display "stream exhausted(while parsing header).")
               (newline))
        ;; ok there's more stuff to read so. Find the ORIGIN string indicating the start of a DNA string 
        (if (equal? #f (>>boyer-moore (string->list "ORIGIN") (lazy-head line-stream)))
            (begin
              (loop-header (lazy-tail line-stream) `(,@info-block-A  ,(lazy-head line-stream))))
            ;; ok found the ORIGIN string 
            (begin 
              (newline)
              (display "found beginning of base pair sequence.")
              (newline)
              (info-block-func info-block-A)
              (loop-base-pairs (lazy-tail line-stream))))))
  ;; well the file is always assumed to start with a header
  (loop-header (lazy-line-stream port) '()))


;; simple function that just displays the base pairs
(define (simple-base-pair-displayer L)
  (display L)
  (newline))

;; now some turtle functions
;; simple turtle moving and turning

;
;(define base-table ;; pun intended
;  '((#\a 23)
;    (#\c 42)
;    (#\t 128)
;    (#\g 15)))
;(define angle-factor 1)
;(define step-len 5)

;(define base-table ;; pun intended
;  '((#\a -3)
;    (#\c -1)
;    (#\t 1)
;    (#\g 3)))
;(define angle-factor 60)
;(define step-len 5)

(define base-table ;; pun intended
  '((#\a -2)
    (#\c -1)
    (#\t 1)
    (#\g 2)))
(define angle-factor 60)
(define step-len 4)

;(define base-table ;; pun intended
;  '((#\a 0)
;    (#\c 1)
;    (#\t 2)
;    (#\g 3)))
;(define angle-factor 90)
;(define step-len 4)


(turtles #t)

;;simple turtle func that will draw a line 
(define (basepair-drawer L)
  (define (draw-loop L)
    (if (not (equal? L '()))
        (begin 
          (turn (* angle-factor (cadr (assoc (car L) base-table))))
          (draw step-len))))
  (draw-loop L))

(define (info-block-func info-block)
  (display "GOT AN INFO BLOCK, STARTING NEW RENDERING")
  ;(display info-block)
  (newline)
  (clear))

(define (post-draw)
  (display "FINISHED DRAWING")
  (newline)
  (sleep 5))
  
  
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; main prog
(define (start)
  (call-with-input-file "ref_chrX.gbk" 
    (lambda (port)
      (process-gbk port info-block-func basepair-drawer post-draw))))
(start)

Boyer Moore Search Algorithm

2008-02-16T14:39:00.000+01:00

I needed to find a String in a text file, so I wrote(rather hacked) a scheme imlementation of the boyer moore string search algoritm.

This is just a hack. But it is commented. What do you think?
(I decided to use this blog also as my cut-paste-source from now on.)


;; searches for string using boyer moore algorithm
(define (>>boyer-moore needle haystack)
  (define needle-len (string-length needle))
  (define hs-len (string-length haystack))
  (define r-needle-list (reverse (string->list needle)))
  ;; two tables are build
  ;; compute the bad character shift table
  ;; it contains the number of chars to skip, if a character is encountered that is not the last of the search string.
  ;; (this table is only used after the search cursor was replaced)
  (define bad-char-shift-table 
    (let loop 
      ((shift 0)
       (nlist r-needle-list)
       (table '()))
      (if (eq? nlist '())
          table
          (if (assv (car nlist) table)
              (loop (+ 1 shift) (cdr nlist) table)
              (loop (+ 1 shift) (cdr nlist) `((,(car nlist) ,shift) ,@table))))))
  ;; the good char table contains the number of chars to skip forwar, if a substring starting from the 
  ;; end of a needle was matched befor a mismatch occurs
  ;; it contains the next possible position from the current search position where a
  ;; string match might end...
  (define good-suffix-shift-table
    ;; for every reverse substring define a shift value
    (let char-pattern-loop 
       ((pattern '())
        (pattern-len 0)
        (nlist r-needle-list)
        (table '()))
      (if (eq? nlist '())
          table
          (char-pattern-loop
           `( ,@pattern ,(car nlist))
           (+ 1 pattern-len)
           (cdr nlist)
           `(,@table 
               (,pattern ,(let loop 
                            ((shift 0)
                             (unmatched (car nlist)))
                            (if (equal? (ncar pattern-len (ncdr shift r-needle-list)) (ncar (- needle-len shift) pattern))
                                (if (eqv? shift needle-len)
                                    shift
                                    (if (>= (+ shift pattern-len) needle-len)
                                        shift
                                        (if (eqv? (car (ncdr shift nlist)) unmatched)
                                            ;; ok nicht gefunden weiter schieben/suchen
                                            (loop (+ 1 shift) unmatched)
                                            shift)))
                                (loop (+ 1 shift) unmatched)))))))))
  ;; searching at a position
  (define  (search-needle-at index)
    (letrec ((sub-hs (reverse (string->list (substring haystack index (+ needle-len index))))) ;; den kaefer erstma aufn ruecken drehen...
             (first-char (car sub-hs)))
      (if (eqv? first-char (car r-needle-list)) ;; first time is special
          ;; if the fist char matches, proceed with subpattern search
          (let ((common (common-sublist sub-hs r-needle-list)))
            (if (= (car common) needle-len)
                0 ;; found
                (cadr (assoc (cdr common) good-suffix-shift-table))))  
          ;;if the first char did not match, look up shift in bad-char-shift table
          (let ((shift (assv first-char bad-char-shift-table)))
            (if (eq? shift #f)
                needle-len ;; return the needle length if nothing better could be found in the bad-char jump table
                (cadr shift)))))) ;; ...otherwise return the value obtained from the table
                
  ;; search mainloop
  (let main-loop ((current-index 0))
    (if (> (+ needle-len current-index) hs-len)
        #f
        (let ((minimum-chars-to-skip (search-needle-at current-index)))
          (if (= 0 minimum-chars-to-skip)
              current-index ;; juhu found string!
              (main-loop (+ current-index minimum-chars-to-skip)))))))
    
       
(>>boyer-moore "ANPANMAN" "NNNNNAXPANPANMANANMAN")

Some utility definitions are missing from the above code, these are:



;; returns the rest of the list after removing n elements
(define (ncdr n list)
  (if (eqv? n 0)
      list
      (if (eq? list '())
          list
          (ncdr (- n 1) (cdr list)))))

;; returns the fist n items of the list
(define (ncar n list)
  (let loop ((result '())
             (rest list)
             (c n))
  (if (eqv? c 0)
      result
      (if (eq? rest '())
          result
          (loop `(,(car rest) ,@result) (cdr rest) (- c 1) )))))

;; return the common begining sublist of two lists
(define (common-sublist listA listB)
  (let loop
    ((listC '())
     (restA listA)
     (restB listB)
     (count 0))
    (if (or (eq? restA '()) (eq? restB '()))
        (cons count listC)
        (if (eqv? (car restA) (car restB))
            (loop `(,@listC ,(car restA)) (cdr restA) (cdr restB) (+ 1 count))
            (cons count listC)))))

The above code might be complete bullsh*t, I dont know I just hacked it down while reading the wikipedia article of the algorithm. I didn't bother to lookup a reference implementation...
Also it was like 4:00 am when I hacked it...(apologies accepted?)

An Alle die dies tatsaechlich lesen...

2007-11-03T17:43:00.000+01:00

... macht euch bitte lustig. Ich selbst nehme mich schliesslich auch nicht so ernst, ausserdem bin ich (und werde es immer bleiben) ein Anfaenger.

This is my zen.

on the path to enlightenment...

2007-09-14T00:25:00.000+02:00

My (and others who I infected) reaction to playing around with erlang, scheme and common lisp, was frustration. Not because these languages are bad, but because they are so nice and fun to programm with! One could even argue, that this alone results in reduced development time and better programms, but while this is definitely true, it hides the fact, that the afore mentioned languages increase efficiency of sw development also by technical means. To provide evidence for this hypothesis is out of the scope of this document, please look for yourself, there's plenty of good material about common lisp, scheme and erlang on the web, there are even life lisp coding videos on google video!

I recently bought the new erlang book. It is great and I would recommend it without hesitation.
There are also great books online that I started reading: htdp and sicp.
Oh and not to forget to mention "little schemers" of wich the chapter about the Y-combinator is online ...(yeahh nice!)

Now, all I need to do is convince my boss to start using erlang or common lisp.

There is just no point in wasting my time with java (except for j2me!).

Blub Paradox

2007-07-25T00:32:00.000+02:00

Ich habe da einen interessanten Artikel ueber das Blub Paradoxon gefunden.
Jenes besagt, das fast alle Programmierer der These zustimmen,
dass Programmiersprachen sich in ihrer "Macht" und Generalitaet unterscheiden, aber trotzdem
nicht bereit sind einzusehen, das andere Programmierespachen besser sind als die, die sie
habituell verwenden.
Verdeutlicht wird das am Beispieln eines eingefleischten "Blub" Programmierers.
"Blub" ist eine P.Sprache die im mittleren Bereich des Generalitaetskontinuums
liegt, das sich zwischen Maschinencode an einem Ende - und Lisp am anderen Ende
erstreckt.
Der Blub Programmierer kennt alle Sprachen, die schwaecher als Blub sind, und fragt sich,
wie man bloss ohne eine Feature "x" vernuenftig programmieren kann(- natuerlich verfuegt Blub ueber x).
Ausserdem findet er, dass Blub alle Features hat die er braucht, und ihm erscheinen features in
"hoeheren" Sprachen als verwirrend und unnoetig. Er denkt in Blub, und Blub ist sein Horizont -
und alle Probleme die er fuer loesungswuerdig befindet, sind in Blub loesbar!

http://www.paulgraham.com/avg.html

functional vs oo

2007-07-15T21:05:00.002+02:00

well it's been a while and I have come to trivial but usefull conclusions lately.
Once I thought functional programming was fundamentaly diffrent then
oo style programming, but I actually realized how well many aspects
of fp match to elements of oop;

Functions are simply Objects,
Closures are anonymous class,
certain design patterns ressemble
monads(decorator, chain of reponsibility,...)

oo style programming can be seen as a restricted variation of functional programming.

That matters because the key aspects of oop is encapsulation and
information hiding. This can easyly be achieved in fp through the
use of closures and the fact that functions can be treated like
any other data.

In oop very explicit notations usually exists, wich couple
certain functions to certain data through the notion of objects. Both, to increase readability of complex programms, and to lighten the restrictions that come with encapsulation, an explicit notion of inheritance is used.

While all this seems pretty obvious to most, frankly, I did not
appreciate oop after doing a a bit of fp, until I found myself reading through some javascript code that I wanted to optimize.
The code was using a many closures like this, which I removed
by placing the variables that the closures contained in
properties of objects, that also contained the functions
corresponding to the closures' code.

When I was finished I had not only increased speed by 40-60%
but was also surprised by the fact that my code looked a lot
like good oo-style code.

So in my opinion every programmer should learn to think functional
in order to get a hold of what the importance of encapsulation and code reuse.

That said, most javascript interpreters(javascript by itself not a purely functional language like haskell anyway) could do this manual optimization of closures automatically.

It is rumored that modern lisp systems and erlang(using HiPE) interpreters/compilers are very close to compiled "C" code performance:
See i.e. http://www.sics.se/~joe/apachevsyaws.html
or http://bob.pythonmac.org/archives/2006/09/21/erlang-binary-performance/

But to emphasis my point of oop vs fp regard this page:
http://openmap.bbn.com/~kanderso/performance/java/index.html

That's it for today.

Recent Comparison of jMock 1.1 and EasyMock 2.2

2007-03-24T19:55:00.000+01:00

My Colleges and me are in the process of figureing out wich mock frameworks to use. One of my colleges has experiences with jMock and I have used diffrent versions of easymock. We wanted a detailed comparison to help us decide what the strengths and weaknesses are of the diffrent Mockframeworks. During a web search we discovered this comparison between jMock and Easymock. Although, regarding the authors background not necessarily, but to me most likely, this comparison of Jmock to an unspecified version of Easymock is biased towards jMock.
Many diffrences/disadvantages in this comparison are obsoleted by more recent versions of Easymock, and speculating on the version used in favour of the author would imho result in 1.3 wich dates way back to 2005.

The desription of the link to the jMock project on the easymock project page, states that jMock opposed to easymock uses

another approach to define expectations that results in more flexibility to set expectations (you may specify almost everything imaginable) at the cost of less flexibility when refactoring (refactorings like method renaming and parameter reordering will break the tests) and loss of code completion when defining expectations or test-driving code.

Well this note is definitely true for older version of easymock, and probably stems from the same era as the comparision hosted on the jMock page. Since version 2.0 easymock started to look a lot more like jMock in terms of behaviuor specification. I found that the easymock approach helped me doing test first programming, in cases where I was not only specifying the class under test but also the mocked interfaces, because modern IDEs like eclipse 3.1 and higher may come up with some fancy hinting/auto fixing feature, that will create non existing methods and classes.

Back to the jMock hosted comparison of easymock vs jMock, one drawback the authour of the comparison states is:

EasyMock lets you change the way that arguments are matched on a call-by-call basis, but the syntax is awkward and same matcher applies to all arguments.

Luckily this is not true for Easymock versions higher than 1.3, but let's take closer look anyway.
As example of how (not awkward and brittle) one specifies the beahaviuor in jmock this code fragment send on its mission to insult its readers intelligence:

mock.expects(once()).method("method1").with( eq(a) );
mock.expects(once()).method("method2").with( same(b1), ANYTHING )
.will(returnValue(method2Result));

Did I just read that a mock object(wich really is NOT the mock object) expects an invocation of a local method called once()(wich it does not), and that the result of the expecation is some object that returns probably a method (wich it also doesnt) with something equal to "a"?
Of course I do understand what this behaviour specification is all about, but to be able to write such a specification, one has to learn a syntax/api not as Java-ish as EasyMock, where the only necessary quirk is the distinction between behaviour recording and verification(wich was clear to me at once when I first saw it).

The author continues to state that:

This means that expectations are more verbose but precisely and clearly specify the expected behaviour of the object.By precisely specifying expected behaviour you get flexible tests¹ that break only when the actual behaviour is different from expected behaviour, and do not break when you make unrelated changes to application code.

To my knowledge it possible - without extensive API knowledge or awkward syntax - to specify any behaviour with abitrarily varied levels of precision with easymock. In jMock you were spoiled with this kind of flexibility right from the beginning, but this flexibilty is achieved only by introducing some drawbacks i.e.:

test development/refactoring is harder because mock-method invocation errors will only show up during runtime
after i.e. adding a parameter to method1 one has even more problems fixing this than merely changing the name of method1

The last point is especially dangerous in a multi developer team. The brittleness of the test cases is exactly what I want. There is added value in compile time checks.

Now let's have a look at the Easymock (2.0 and higher) version of the code snippet:

mock.method1(eq(a));
expect(mock.method2(same(b), anyInt())).andReturn(method2result);

Notice the subtile diffrences, in jMock one provides the method parameters in a non typesafe way through the "with" method, while in easymock one provides the arguments matchers where the actual parameters would be written. Also through the use of Java 5 generics in easymock the behaviuor definitions can be checked at compile time for type related mistakes.

Another great diffrence between the two examples are that in the jmock example "mock" is a control object and in the easymock example, "mock" is the mock object, that implements the interface we wich to "mock".

One drawback of easymock is that because method1 returns void we have to call "expectLastCall()" to get an object that allows us to specify some more expectation
like the number of invocations of the last method:


mock.method1(eq(a));
expectLastCall().anyTimes();

expect(mock.method2(same(b), anyInt())).once().andReturn(method2result);

Another more recent comparison dated around march 2006, seems to be done with a newer version of easymock, but it seems that also the author did not (yet) regard/compare more than the absolute minimum mock framework features one might want to use. The key point in favour of easymock were

method identification through actual method of the proxy
no extension of testcase base class
mixing of class mocking and interface mocking is very easy (you just use another implementation of MockControl)
very low API complexity

The points in favour of jMock were:

No control object is required
no replay/verify steps are necessary

Lets shed some more light upon this comparison:
The main point, that no control object is required in jMock is imho false. One exclusively operates on the control object and invokes a getter for the proxy. That is the reason just why
one cannot use the actual methods to specify behaviour. Easymock achieves refactoring safe actual method specification by introducton of its replay/verify concept. Furthermore, by exploiting new Java 1.5 features(static imports, generics, varargs) easymock almost completely frees the user from the burdern of being aware of this dichotomy in his daily work, and it even frees the user from the burden of subclassing some special test case base class as in jMock.

JMock on the other hand allows the user to specify behaviuor without having the recording/playback states, and mock behaviuor is automgically verified by base class methods after the method finishes. Also mock control object can be instantiated by a base class member method.
While this is for sure some helpful syntactic sugar, it is not so hard to do any of this with easymock because of the clever design of the easymock MockControl class and the usage of static imports.

Also the possibility to specify argument matchers was judged as "difficult" in easymock and easy in jMock.

Finally, I would like to point to an interesting article done by Martin Fowler, who explains some interesting aspects of overall applicability of Mock/Stubs/Dummies and Fakes, and tries to open a more general perspective on test doubles of all kinds. He also includes a small comparison of jMock and EasyMock. He also compares jMock to a very outdated version of Easymock it seems, as the code he provides as example, does not make use of the "import static" feature of Java 1.5, as well as some other features that could have been used to make the code alot more like typical jMock code. The article can be found here.
Although this article was updated 02 Jan 07
the easymock example he provides is also based on an obsolete version of easymock. Exactly why the author values mentioning some diffrences between jMOck and easymock is not clear to me. The article focuses on explaining the distinction between stubs and mock, not on comparing mock frameworks.
I will use this opportunity to rewrite this example of easymock:


public class OrderEasyTester extends TestCase {
private static String TALISKER = "Talisker";

private MockControl warehouseControl;
private Warehouse warehouseMock;

public void setUp() {
warehouseControl = MockControl.createControl(Warehouse.class);
warehouseMock = (Warehouse) warehouseControl.getMock();
}

public void testFillingRemovesInventoryIfInStock() {
//setup - data
Order order = new Order(TALISKER, 50);

//setup - expectations
warehouseMock.hasInventory(TALISKER, 50);
warehouseControl.setReturnValue(true);
warehouseMock.remove(TALISKER, 50);
warehouseControl.replay();

//exercise
order.fill(warehouseMock);

//verify
warehouseControl.verify();
assertTrue(order.isFilled());
}

public void testFillingDoesNotRemoveIfNotEnoughInStock() {
Order order = new Order(TALISKER, 51);

warehouseMock.hasInventory(TALISKER, 51);
warehouseControl.setReturnValue(false);
warehouseControl.replay();

order.fill((Warehouse) warehouseMock);

assertFalse(order.isFilled());
warehouseControl.verify();
}
}

Here is the rewrite:

import static org.easymock.EasyMock.*;

public class OrderEasyTester extends TestCase {
private static String TALISKER = "Talisker";

private Warehouse warehouseMock;

public void setUp() {
warehouseMock = createMock(Warehous.class);
}

public void testFillingRemovesInventoryIfInStock() {
//setup - data
Order order = new Order(TALISKER, 50);

//setup - expectations
expect(warehouseMock.hasInventory(TALISKER, 50).andReturn(true);
warehouseMock.remove(TALISKER, 50);
replay(warehouseMock);

//exercise
order.fill(warehouseMock);

//verify
verify(warehouseMock);
assertTrue(order.isFilled());
}

public void testFillingDoesNotRemoveIfNotEnoughInStock() {
Order order = new Order(TALISKER, 51);

warehouseMock.hasInventory(TALISKER, 51).andReturn(false);
replay(warehouseMock);

order.fill((Warehouse) warehouseMock);

assertFalse(order.isFilled());
verify(warehouseMock);
}
}

to be continued...

Future of Webdevelopment

2007-03-16T23:27:00.000+01:00

The longterm future in Webdevelopment is for sure associated with fading boundaries between systems that provide a service wich incorporates distributed knowledge to form new knowledge, wich it distributes, probably only to one client in a secure fashion.

These boundaries are hard boundaries in terms of possible incompatibilities between interacting systems in heterogenous environment. We are confronted with securtiy issues, incompatibilies in protocol interpretations and service metadata propagation for automatic wiring of resources as opposed to hand crafted wiring as i.e. done with hyperlinks between dynamic system with a proprietary but similar structure, we are confronted wich diffrences on many layers of abstraction and orthogonal technical aspects like the necessesity to transform data not only to diffrent semiotic representationens but also to devices with diffrent availibility and diffrent means of human interaction.

As diversity greatly increases, the call for unification and simplification, that emerged from the complexity, gets louder and louder - and is eventually the root for the development of simple webframeworks of wich there are many(i.e. ruby on rails and groovy).
I think that while it is not the true path to oversimplifiy things, it is at the same time not much better to overcomplicate a specific system, that is the result of what can be refered to as webdevelopment activity to a state, where user recognized functionality of such a system is superseded by a system done by less less developers in less time.

It is also most often perceived, that many legacy systems exist, wich have grown old and big over many years, and wich are hard to extend or modify, but due to their long term presense have somehow proven to work and also have delivered ROI. They also mirror long time adaption to many improvements and changes that were realized required as the system faced reality year after year;
such a code contains real world experiences, that might be worth keeping. These nuggest often have the downside of not being documented properly, so that are hard to extract and a rewrite that preserves the current state of the system get expensive.

I see a need for some kind of methodology that allows to ¨pimp¨ existing legacy applications so that they are interoperable with modern web technologies.
I will have deeper look at REST based webservices, and means of simple object serialisation.
I am eager to create some utility that will adapt existing and new Java applications to web basesd interaction partners, be it a webbrowser rendering an Ajax based user experience or a machine utilizing a service offered by the Java application.

Back again

2007-01-16T21:35:00.000+01:00

After a lot of meditation over efficient programming styles, some new ideas finally condensed in my defected mind:

always underestimated is the emotional aspect of coding, in a team environment one must be able to critisize and be critizised; also bad code pisses me of so much, that it pulls down my overall productivity
test driven development saves time, most of the time
clear structure and good documentation helps, because maintainance will be nicer (see 1.)
usefull integration testing is a far away dream, never to be reached in a pure XP manner including acceptance tests.
jira is cool - combined with good ole paper on the wall does best. customer requests - the customer(or any other person not a freak) will not put sufficient details for a bug or a feature request into the bugtracker or be helplessly faced with a complex and flexible task of specifeing an issue, here improvements to the GUI to reduce complexity by providing more project specific defaults would be nice)
wikis are usefull, although sometimes they suck!
eclipse on badly configured linux workstations sucks, too..
everything in the world could be modelled by interfaces ... but doesnt have to be....
doing today what you think, you might need next year, and hence imposing privations upon oneselves until next year, just to realise then, that you have to do it a diffrent way due to some fucked up details, well ... this actually does suck, also very badly
well, ... and last but not least... using Java for web applications sometimes sucks too: no higher order functions, no continuations, no cool typesystem, apart from some bright highlights: laborious and longnamed language syntax

Open and closed Source voting

2006-10-09T13:31:00.000+02:00

In several countries voices are raised against the use of voting computers. The latest objection was raised by the CCC in germany. According to security analysis, voting machines are insecure, and allow for untracable manipulation of voting results and voter privacy. The software can be exchanged and votes could be manipulated without any traces. The systems used for voting in Germany are very similar to those in the Nederlands. Similar objects were raised before in this country. Andy Müller Maguhn wrote:

Die Bauartzulassung der Nedap-Wahlcomputer ist nach den nunmehr vorliegenden Forschungsresultaten hinfällig. Das Bundesinnenministerium muss daher die Zulassung entsprechend § 3 Absatz 3 der Bundeswahlgeräteverordnung widerrufen

It does not surprise that similar story are percepted in the USA, where some rumour around the company "Diebold Election Systems" raised, after a group of college students found some memos about the poor security of the system from developers of this company, which somehow sliped onto a public area of the companies website.

After the companies lawyers tried with the help of the "Digital Millennium Copyright Act" to force the university to remove these memos from the servers(yes they are copyrighted material...) the sutdents had to use peer to peer file shareing software to keep the memos online.
The NY Times wrote in an article:

The files circulating online include thousands of e-mail messages and memorandums dating to March 2003 from January 1999 that include discussions of bugs in Diebold‚s software and warnings that its computer network are poorly protected against hackers. Diebold has sold more than 33,000 machines, many of which have been used in elections.

Now a debate araised around the question wheter voting software should be open source or closed source, to assure maximum demoncracy. While I think that one should also keep in mind that the main problem of demoncracy is missing participation, I am convinced that an open source solution is the only appropriate way to ensure a secure voting process.
Clive Thompson wrote:

So now you're caught up. The reason I give this bloated preamble is to point to the real solution: Open-source software.

As the Diebold scandal illustrates, it's incredibly dangerous to let a private company develop proprietary voting software. If they "own" the code, they'll keep it a secret. That means we'll have to trust them that the software is secure. If they're lying to us -- or, more likely, if they're well-intentioned but just unable to realize how buggy their code is -- democracy is screwed.

Open source software could be manipulated by enemies of demoncracy, but that, at least would show up immediately, and it is an advantage of open source software, that the participants are not bound by any contracts or employers, and may talk freely about the problems of the software without the vendors commercially motived blur.

I therefore disagree with Barry Briggs, who answers to Clive Thompson:

I don't think it's perfect at all. Open-source rests on several cornerstones including programmer anonymity and zero accountability. What if we were to find out that a key contributor to our voting machine software was a member of Al-Qaeda?
In fact, the last people I'd trust to verify the correctness and trustworthiness of something as critical as voting machine software would be a loose group of international programmers who could care less about the integrity of our republic.

And who will be eager to write such software? Of course not the enemies of demoncracy, but those who realize the very value and importance of free elections. And it is really motivating to be part of the team that wrote the software, that drives a vital part of the election process.

Links:

Real Programmers :-)

2006-10-06T15:16:00.001+02:00

Real Programmers Don't Use Pascal!

Java Locking

2006-10-06T14:49:00.000+02:00

Here are some nice Articles about Double checked locking, the singleton pattern
and the friendly comepetition between people doing VM level locking (aka Synchronized) and Java locking (1.5 Reentrant locks)

AMDD

2006-10-05T12:23:00.001+02:00

I like MDD, SCRUM and extreme Programming, so AMDD just seems so natural.

AntiPattern: AbstractionInversion

2006-10-02T15:58:00.000+02:00

After trying to understand the AbstractionInversion antipattern, I wonder if this pattern is really a unique pattern and not actually more like a combination of other, more abstract AntiPatterns.

Is AbstractionInversion a special case of code duplication, where a dependend class not only duplicates effort, but also escapes its level in a stack of abstracness layers inside an application?

It seems to be common to most examples I have read so far, that AbstractionInversion occurs in conjunction with code/concept duplication in two dependent modules with diffrent levels of abstraction. To explain my thought I will rely on the ADA RendezVous example mentioned here.

If i.e. a mutex is implemented by using the RendezVous concept, a mutex concept is actually implemented by using something at least as complex as a mutex, and code is likely duplicated.
Furthermore the one-class-one responsibility rule seems violated in the above example, as the abstraction to the gory details of the model relate to the concepts used in order implement the level of abstraction used by a dependend class, that itselfs tries to escape its level of abstraction by using concepts with a much lower level of abstractness that would actually be appropriate for the position of the dependent class in the hierachy of abstractions.

Does AOP solve the problem?

Another observation in the ADA example is, that abstraction invsersion stems from some backdraws of object oriented desing, wich lacks efficient and clear modeling of cross cutting concerns(like Mutexes), and therefore confuses unexperienced developers, by creating the temptation to include certain aspects into strict hierachies of abstractions, aka class hierachies, even if this is not required by the application domain, but merely by technical issues.

New Emoticons

2006-10-01T23:18:00.000+02:00

Every owner of a german keyboard, will know these already, but might not have noticed them as first class emoticons painted so obviously on the keys ...

and

Java Development Tips

2006-09-24T19:57:00.000+02:00

Oh, if they would just read it...

http://www.squarebox.co.uk/download/javatips.html

The purpose of the MOCK

2006-09-18T15:29:00.000+02:00

In response to a much nicer blog entry, that can be found here.

There are actually several distinct "tests" that make up usual unit tests, among them two that really do stand out:

one kind of testing to test method flows,
one to test some sort of computation.

Mock objects are for the purpose of testing method flows. A method flow is a series of message transmissions to dependent objects.

The control flow logic inside the method(the ifs and whiles) will alter the flow

in repsonse to the parameters of the method call parameters passed by calling the method under test,
depending on the state of the object that contains the method under test and
the return values of the external method calls(aka responses to the messages sent).

There should be one test method for every branch of an if statement, and usuale some sort of mock control objects in the mock framework will handle loop checking.

BTW: I partly use message transmission instead of method invocation to include other kinds of "not really method invocations" like "exceptions".

The author of the afore mentioned post is quite right with his observation, that his test resembles the method under test quite closely, except, of course, for the control flow code(loops, conditionals). And that is absolutely desired, as he is testing mainly the "method flow" - there is not much computation necessary in JDBC code like this anyway.

It is tempting to raise the objection that a change in the order of messages sent to another object inside the method under test will result in a failing test, but it is easy to perceive the fact that the order of messages send to ONE object SHOULD be relevant. If it is not, well then there is no point in changing the method under test, isn't there?

Even if the method under test send variuos messages to various distinct objects, the order will be relevant at some level of abstraction. Therefore mock-checking of the order of method invocations can be(and must be) adjusted, at least if multiple distinct objects are addressed by the method under test.

And nothing else is it, that the author proposes, although, a little more complicated, than necessary when using easymock, for what I know.

Free Programming Books

2006-09-15T16:37:00.000+02:00

I stumbled over some not so common class of free programming books:

Although these books are not the most recent spiffy Ajax/Java books, the are worth reading:

Maven Changelog plugin

2006-09-14T18:08:00.000+02:00

I tried to use the maven changelog plugin, as described here
but maven complained that it could not find the plugin!

That was due to the fact this plugin is not yet stable, this wasnt mentioned anywhere I looked.

To enable the plugin you must first add the apache maven snapshot repository, read this site to find out how.

AntiPatterns

2006-09-13T03:01:00.000+02:00

I just realized some nice Articles in the English and German wikipedia about anti patterns. I was well aware of the existence of software engineering related anti patterns, but I read about two other categories of anti patterns, well explained in the afore mentioned articles:

organizational&project management anti-patterns
and Meta-(anti)-Patterns

I found it both enlightening and shocking to learn about these patterns. Nevertheless the most funniest were IMHO:

Programmer Experience Clumping
Fear of success
Management by numbers
Single head of knowledge

Sources:

Maven Source-Formatting/-Metrics

2006-09-12T22:06:00.000+02:00

I needed to add source code formatting and some code metrics to my maven based project. These are the places on the web where I found help.

I wanted to get the Jalopy plugin to format my source code, and promptly failed to get the snaptshots from the mojo projects without the help of this resource,
this resources helped me to get the codehaus mojo snapshot plugins:
What to put in settings.xml

after that I could simply run:


mvn  -Pcodehaus jalopy:format

As I was bothered by the command line cluttering by -Pcodehaus, I actived the profile by adding <activeByDefault/> into the activation tag in the profile definiton for the "codehaus" profile.
Now ....


mvn  jalopy:format

... and voila! Jalopy formatted my sources.

See also: maven Jalopy plugin

Very helpful for the "other" reports was an interesting java world article...

I also wanted JDepend to check my project, to I added Jdepend.

my first migration of a legacy project to maven 2

2006-09-12T17:21:00.000+02:00

I had to do migrate a legacy webstart swing application to the maven build process. The app was build into several(signed) jars from a single source directory(containing a mix of java files, property files and html help files). The app was deployed with webstart.

Sometimes the pom file reference and settings file reference were helpful...

Important is the introduction to maven lifecycles.
Interresting is the fact, that maven uses plexus container for IoC, reading the comparison, I figured I should try using plexus in another project...

These are the steps that needed to be done to migrate the project:

1. Install 3rd party jars into the local repository
- I checked in this repository

2. use the maven2 jar plugin to create a manifest wich points out the main class:
Maven2 Jar plugin

3. use the jar plugin to sign the jar
- use the maven keytool plugin to create the keystore automatically after reading this page.
- add the jar plugin sign goal

4. use the assembly plugin to creat a a zip file with my (bad practice) manually created jnlp file.
- read the assemply plugin introduction

this pages describes howto use the maven-antrun-plugin.

5. create the appropriate ant build file

Maven 2 3rd Party Jars

2006-09-12T15:18:00.000+02:00

Maven: Installing 3rd Party JARs
This page states that one should install a file into the local repository; But another option I found more useful in a team development environment is to deploy 3rd party jars to a maven repository in the companies network via ssh/scp.

If multiple developers work on the project it is advisable to have a linux box somewhere with an ssh server installed and apache running. Just configure this
server in your settings.xml and define the deployment to use that server.

All 3rd party jars, the project website/reports and the project itself can then be deployd to that server with this:


mvn deploy:deploy-file -DgroupId=        -DartifactId=        -Dversion=        -Dpackaging=        -Dfile=        -DrepositoryId=        -Durl=

Taken fromhere.

I truely love maven ;-)