Programmer's Weblog

pinfruit - my mnemonic web app for memorizing numbers

noreply@blogger.com (Kamil Dworakowski) — Thu, 13 Jan 2011 01:09:00 +0000

I have created a web app to memorize numbers. It implements the mnemonic major system. The system works on the principle that it is easier to remember words/sentences/stories than numbers. The web app facilitates finding sequences of words that encode a number in the mentioned system. I called the app pinfruit.

My first take on implementing the system was incorrect. I simply associated digits to letters. According to wikipedia the mnemonic major system assigns digits to sounds, rather then the letters of the alphabet. And rightly so, I immediately noticed that it is easier to work with sound associations.

My mistake originated in that I first learned the technique in Poland, and in Polish it does not matter if you assign digits to letters or sounds because both correspond. Unfortunately, in English this is not the case, the major difficulty in learning the language.

I have used pinfruit to memorize mainly pins and phone numbers, but also bank site's user identifiers, which often come as numbers.

The trick is to create a memorable (vivid or absurd) sentence/story for a number. My old phone number: 07514590312, can be encoded with husky leader leaps midway Hanoi, school weather helps Madonna or sickly water leaps hometown. I refer you to the wikipedia article for the detailed description of the system.

From layers to hexagonal architecture

noreply@blogger.com (Kamil Dworakowski) — Sun, 15 Aug 2010 20:41:00 +0000

The traditional layered architecture consists of data, domain and presentation layers.

Separating the presentation layer from the domain layer is rather easy. The presentation layer objects query the domain for data to display on the screen. The persistence layer is another story. The fact that it appears below the domain layer prohibits any of the classes in it knowing about the domain entities.

But consider a Fetcher class for example, a class that has responsibility for querying some domain object from the database. It has the domain type in the signature and thus has to be defined in or above the domain layer. This is leaking of the data access object out of the persistence layer.

This problem has been recognized and here we have an architecture which works around it by separating out the domain objects package. But the result is not as clear and compelling as the layered architecture.

The civilisation progressed and an architecture with nothing below the domain model has been discovered. One can see this in the ddd sample.

The persistence concern is implemented as part of the infrastructure layer. Infrastructure is that vertical layer that depends on the three other layers. Domain knows nothing about the infrastructure.

Another example is the Hexagonal Architecture.

The domain sits in the core of the application, with the persistence aspect implemented by an adapter. The adapter layer corresponds to the infrastructure and the interfaces layer combined from the ddd sample architecture diagram. The important part is that the domain does not depend on anything else.

Such layering is achieved by defining service interfaces in the domain layer for persistence purposes. These abstract interfaces are implemented by the adapters in the outer layer of the application and injected into the objects that need them.

As a result nothing in the domain layer needs to import anything from the hibernate package, or whatever persistence technology is being used. The domain layer has a custom made, abstract interface to persistence service, in its own terms. The domain code can be expressed without the details of the persistence technology being used.

GOOS Book

noreply@blogger.com (Kamil Dworakowski) — Sat, 27 Mar 2010 12:53:00 +0000

Growing Object-Oriented Software, Guided by Tests by Steve Freeman and Nat Pryce is a book I was long waiting for. GOOS demonstrates the techniques and highlights the patterns as they show up in an application grown through the book. An albeit small but a real world project is being developed from scratch in a way were tests play as important a role as object-oriented design.

It is an excellent opportunity to see how two skilled developers are growing application. The authors work in TDD in a style characterised by extensive mocking to avoid breaking encapsulation. In design they use fine grain classes. All together the style demonstrated in the book is very consistent.

IronPython Dictionaries Memory Cost

noreply@blogger.com (Kamil Dworakowski) — Sun, 07 Feb 2010 18:03:00 +0000

Maintaining a mapping as a dictionary can be quite expensive in terms of memory, more than one would expect. A couple of days ago I have checked with windbg how much a single entry in a dictionary mapping pairs to ints costs. The code I measured is:

d = {(1, 2): 3}

I have executed it in IronPython 2.6.

The graph below depicts what I saw on the heap. Each box represents a single word in memory. In a 32 bit system, a word is 4 bytes.

Every object in .NET runtime has an overhead of two words. These are the pointer to its class and some house-keeping data, which I don't know much about. Allegedly some part of it is used for object locking.

The graph shows objects below buckets array, these are the only that count. A dictionary is a hashtable which is implemented with an array of buckets. Each item in the dictionary is kept in a bucket. The size of the Bucket object determines the size of an entry in the dictionary.

There are 23 boxes in the Bucket's subtree, which means its size is 23 * 4 = 92 bytes. Quite a lot. A million numbers in that dictionary would take almost 100 megabytes!

The main reason it comes out as that many is the generality of the dictionary. The fact that it can store objects of arbitrary types means that the numbers must be boxed. .NET generic collections, when specialized for ints, would store numbers in place saving a lot of space.

Unobtrusive highlighting of trailing whitespace in Vim

noreply@blogger.com (Kamil Dworakowski) — Sun, 13 Sep 2009 12:27:00 +0000

Many programmers highlight trailing whitespace red to expose that unnecessary gunk that is otherwise hard to spot. I did not much care about trailing whitespace, it was never a problem for me, though now the distributed version control systems tend to complain about this.

Highlighting the trailing whitespace is effective but has this unwanted side-effect of a red thing appearing under the cursor when typing space at the end of line (most of the time I type space at the end of line it seems).

This set of commands will only highlight the trailing whitespace on opening the buffer and leaving the insert mode. Inspired by the Vim tip wiki.

highlight ExtraWhitespace ctermbg=red guibg=red
au ColorScheme * highlight ExtraWhitespace guibg=red
au BufEnter * match ExtraWhitespace /\s\+$/
au InsertEnter * match ExtraWhitespace /\s\+\%#\@<!$/
au InsertLeave * match ExtraWhiteSpace /\s\+$/

Some notes: ctermbg=red is for vim, guibg is for gvim. The second line is to prevent any color scheme to override the highlight settings.

OK, that feels better.

Extreme programming too extreme?

noreply@blogger.com (Kamil Dworakowski) — Tue, 09 Jun 2009 13:21:00 +0000

Is extreme programming as a methodology over? Has Kent Beck killed it himself? Until now he insisted that you not write a single line of code without a failing test. He was talking about his daughter who allegedly can not even imagine writing code without tests first (in his book about test driven development)!

Extreme programming is a set of good practices but the problem is the emphasis on taking them to the extreme thus ignoring the cost/benefit ratio. There is an obvious trade-off here.

It would be optimal if people wrote just the right amount of tests, not too little and not too much, to maximise the ROI. That of course is very hard to judge, but for sure the answer is not 100% coverage in all cases, as Kent kindly observes in his post.

Extreme programming is flawed as a methodology, but I want to argue that it is good for learning the craft.

People have natural inclinations for not testing, not integrating continuously but programming a feature for days not syncing with the main code base, underestimating features and than putting in long hours, etc. Extreme programming is like a correction program for these unwholesome inclinations. :)

Aristotle noted in the Nicomachean Ethics that the best way to reach the golden mean is to aim at the opposite extreme.

In the dimension of testing, for example, people will naturally tend to write too little tests, usually none. Practising extreme programming forces us to go to other extreme: from none tests to 100% coverage no matter the cost. This teaches that you can write tests you didn't previously realized, but more importantly it changes the mindset of the programmer. After practising extreme programming you will find yourself uncomfortable without the safety net of tests, and while you will not necessarily want 100% coverage you will be in a much better position to judge how much testing is really needed.

I am glad that I was a part of an extreme programming team for almost 2 years now. We might have been too extreme, but too extreme in the good direction. 4:1 ratio of tests to code that we have might be an overkill, but it is certainly better than no tests at all. I feel similarly about other practices.

Applied computer science

noreply@blogger.com (Kamil Dworakowski) — Fri, 22 May 2009 21:00:00 +0000

"Don't worry about people stealing an idea. If it's original, you will have to ram it down their throats." It looks like one of those optimistic sentences that are supposed to lift spirits. And some people must believe in it, I suppose, because otherwise it would not circulate.

Each time I stumble upon it, it reminds me of NP problems. In general: finding a creative solution to a problem seems to me to be a lot like finding a solution to an instance of a NP problem.

Just a reminder, an NP problem is such for which there exists a nondeterministic Turing machine solving it in polynomial time. Most people think that P!=NP, so problems that are in NP and not in P require exponential time to solve, but just polynomial time to check if a solution is correct.

So here, a whole class of problems, for all of which it is hard to find a solution, but easy to see that a given solution is good. Boy was it worth taking those computational complexity classes at the university ;).

Sony PRS 505 ebook reader review

noreply@blogger.com (Kamil Dworakowski) — Sat, 16 May 2009 10:47:00 +0000

I use Sony PRS 505 for more than a month now (see how it compares with other readers). It came with 100 classic books, all of which look very tempting. I have already read over 1000 pages of David Copperfield.

(BTW, the Reader shows the beginning of the first chapter of the new "IronPython in Action" book, by my colleagues Michael Foord and Christian Muirhead.)

They say that the battery life is 5000 page turns, but mine died after about 1000 pages of mentioned David Copperfield. I have been playing with it, and sometimes going back and forth, but for sure that was not 4000 page turns worth of playing. Anyway, the battery life is very good, but the 5000 page turns is misleading at best.

The device comes with software for windows. It is not really a problem for a Linux user, because you can mount the reader like a usb stick, and copy the books directly - that is how I do it at least. There is calibre project that is supposed to be heaps better software for the reader than the official one, but it doesn't start on my system and I don't see any reason to investigate -- I'm fine with cp.

I have it for over a month and think it was worth every single pound I payed for it. I write the review now, because I have finally bought an ebook on-line and put it on the reader. That feels right. Although, in the meantime I had to buy one dead tree book simply because there was no ebook available. Hopefully that will not happen often as amazon's Kindle gains popularity.

My biggest wish is that the screen was larger. Looks like the upcoming Kindle DX is going to be the right size, though it is going to have a lower resolution than the Sony Reader. I bet that other manufacturers are already working on a larger version to compete with DX.

The small size is not really right for books with code and mathematical formulae (most cs papers and technical books). I found that putting the reader into horizontal mode (buried down in the settings) helps a lot with that.

Unlock Huawei E220 - soap on a rope

noreply@blogger.com (Kamil Dworakowski) — Sun, 10 May 2009 17:30:00 +0000

I have successfully unlocked myself a T-Mobile Huawei E220 modem. I followed the tutorial at unlockE220.com. However, at step 4 I could not find the specified string. I suspect that might be due to firmware upgrade on the device. Anyway, I have worked around it, so please follow the tutorial, and if you get stuck at step 4, read what follows here.

The unlock code is supposed to be string of 8 digits. First let's find all the strings in the Flash.bin, created in one of the former steps; I used the strings command line program (in cygwin) to do it.

strings Flash.bin > 'code-candidates.txt'

Now, the code-candidates.txt contains all the strings, one per line. We are only interested in the ones composed from digits and at least 8 character long. Here is a python code that reads the file and prints all possible codes.

for l in open('code-candidates.txt').readlines():
    l = l.strip()
    if not all(map(lambda x: x <= '9' and x >= '0', list(l))):
        continue
    if 8 <= len(l):
        print l

Assuming you saved the above code fragment as find.py, the command line to print the codes is:

strings Flash.bin > 'code-candidates.txt'
python find.py

In my case it printed 10 or so codes. Try them with the unlock program provided at unlock220.com. Surprisingly, the unlock program reported success for 3 of the codes, but only after I tried the last one had my sim card got accepted.

Twitter outage

noreply@blogger.com (Kamil Dworakowski) — Sun, 29 Mar 2009 11:12:00 +0000

Twitter has been down for me for about a week or so. Every time I logged in it would say "something is terribly wrong". I tought it was down for everybody - you know twitter :) - until I read Menno's post where he reports about masive tweeting at PyCon. I have just reset my password and everything is right again. Odd.

Quad Head

noreply@blogger.com (Kamil Dworakowski) — Sat, 14 Mar 2009 16:11:00 +0000

In popular opinion programmer's job is just sitting in front of a computer, each day. It is true it the same sense as life being just eating, each day. But I am not trying to convince anyone here. I want to say that I for one am not sitting in front of just any computer; I am sitting in front of a deathstar control center*! Pictures attached ;).

OK, back from orbit. I have been using this setup at work for over a month now and would like to share my observations. I expect many of you to have reservations as to the added value of additional monitors. You probably think that four monitors can't be bad but likely not much better than two.

It depends on the type of activity. When browsing (reddit, blogs, wikipedia), one monitor is usually enough. But when programming I often wish I had more than four. Traders have long known about the value of using multiple monitors.

The reason it is so good for programming is that the activity requires to keep millions of things in the head at once -- names of variables, functions, classes, third party APIs. You can keep limited amount of things in your head, depending on various factors affecting your concentration like amount of sleep the previous night. You will have to page fault to the rest. And when page faulting requires switching between windows it adds friction. Energy that could have been used on solving problems is wasted.

When pair programming the problem is even more itching. The pilot (the person who has no control of the keyboard) has a high cost of page fault -- he needs to ask the driver to "show the page he needs". This request will probably also disturb the concentration of the driver.

Allocating windows across monitor is crucial. You want to have the information you will need most often readily available. What you don't want is to have two windows to which you need simultaneous access being on the same monitor.

Even with four monitors, you will find that you have more than one window on the same monitor. My average is about 2-3 windows per monitor and 2-3 virtual desktops (don't worry I don't use splits ;). For past month I had one virtual desktop for lunch time, one for spiking an interactive console for Resolver One, and one for main development.

Vista is not really well prepared for 4 monitors; windows appear on different monitors at random. It is not unusual that an application on monitor 4 will popup a dialog on monitor 1. Without some third party tools it would be a chore to manage it all. I use winsplit for moving windows around, vdm for virtual desktops and ultramon for extending the taskbar.

For over a year now I am used to open two separate gvim instances, one for the module under test and one for the unittests of that module. This arrangement fits very well with test driven development, which involves frequent going back and forth between tests and module under test.

* My desktop was named deathstar control center by Jonathan.

HLint

noreply@blogger.com (Kamil Dworakowski) — Wed, 04 Feb 2009 12:22:00 +0000

I am used to pylint, which runs at the start of a build to ensure code quality. If pylint complaints, the build is broken, so I run it prior to any commit to avoid embarrassing BUILD FAILED emails sent to all developers by CI.

No one has high expectations of such a tool, it just reports unused variables and imports or redefined names. It also annoyingly complains about defining names such as file, that shadow builtins. Well, I guess different people are annoyed with different aspects of it. Anyway, my point here is that this tool is simple.

I was thrilled to see HLint suggest that instead of reverse . tail . reverse I could just use init.

./Goals.hs:137:1: Error: Use init
Found:
  reverse . tail . reverse
Why not:
  init

That is just whole new level. It also highlights redundant brackets:

./Controller.hs:17:1: Warning: Redundant brackets
Found:
  (priority n1) `compare` (priority n2)
Why not:
  priority n1 `compare` priority n2

And look at the next one,

./Controller.hs:17:1: Warning: Use on
Found:
  byPriority n1 n2 = (priority n1) `compare` (priority n2)
Why not:
  byPriority = compare `on` priority

I had no idea that `on` existed. How awesome is that? As if by sufficiently advanced technology HLint knows better how to code than I :).

The tool was created by Neil Mitchell, who is also responsible for Hoogle -- Haskell API search -- which I use daily.

It is available thorough cabal install, but cabal install hlint didn't work for me until I cabal installed happy.

Snowing in London

noreply@blogger.com (Kamil Dworakowski) — Mon, 02 Feb 2009 21:00:00 +0000

It was snowing today in London, or as BBC holds it, there were severe weather conditions. By Polish standards, it was nothing special, but London was unprepared. I didn't realise how bad it was until I read an e-mail from Orestis, that he doesn't want to risk coming to office. I had no idea underground did not work, I live in a walking distance from the office and today I was 10 minutes early.

On my route to work I saw palms under snow.

Anyway, that must have been great day for kids. If not for snow then at least for closed schools. I took that photo in the evening. Yes, that snowman has style and surely many bitches, and yes, he wears silver $ on his neck.

Not only schools were closed. I needed to go to Lloyds TSB, you know, the bank with the most branches. My branch greeted me with this:

Weather conditions, yada yada, they are sorry, and point me to another branch. Guess what, that second branch had a similar note pointing to third branch. At this point I was sure that the third branch will close the cycle. I was wrong, the third branch had a note saying that they are indeed open, but only till 2pm; unlucky for me it was 2:15.

I was pretty amazed when I first learned the notion of Bank Holiday. Idea that no other business can operate when banks are shut still seems dubious to me. Far more convincing is that no other business can operate without the tube.

I am supposed to fly to Poland tomorrow, but all the today's flights were cancelled. The weather is supposed to be the same tomorrow, my only hope is that the UK will get better at coping with the snow.

Beautiful Code: Resolver One

noreply@blogger.com (Kamil Dworakowski) — Tue, 20 Jan 2009 08:56:00 +0000

Resolver One, aka the Python Spreadsheet, has a beautiful design at its core, which I would like to present to the programmer community. No knowledge of Python is necessary to understand this article.

The goal for the application is to provide seamless integration of spreadsheet (formulae in the cells) with sequential code. In MS Excel the VBA integration is anything but seamless. In the rest of this post I explain how Resolver One integrates Python with spreadsheet functionality.

Spreadsheet

To ensure that we are on the same page, I'll pinpoint some facts about spreadsheets. In a traditional spreadsheet there are two types of content a cell can hold:

constant: like number, date or text
formula: an expression usually referencing other cells

A user can enter this content by typing to a cell. Additionally, a user can specify formatting for a cell by various GUI means; for example, make the cell's font bold by clicking a toolbar button.

How do you add sequential code to it? Resolver's solution is to turn the spreadsheet into sequential program. User's custom code merges with the rest of the spreadsheet thus expressed.

Spreadsheet as a program

In Resolver One, what you see in the grid is the result of executing the code displayed in the coding pane.

Following is the code that appears in a document created with File | New command. I have pruned it by dropping comments and not required import statements.

from Library.Workbook import Workbook

workbook = Workbook()
workbook.AddWorksheet("Sheet1")
workbook.AddWorksheet("Sheet2")
workbook.AddWorksheet("Sheet3")

Constants = {}
Formatting = {}
workbook.Populate(Constants, Formatting)

The above featured code creates a workbook with three empty worksheets.

Where did the code come from? Resolver One generated it from the model. By model I mean the data structure that remembers constants, formatting and formulae input by the user through the GUI interface.

The drill is: Resolver One generates code from the model, executes the program, takes the resulting workbook object and displays it in the tabbed grid view. This is called recalculation.

Every time the user changes the model through the GUI commands, a new recalculation is triggered. The next snippet presents code after me changing the model by typing to some cells in the grid, I want to give you a feel of the generated code. I put number 1 into A1 and formula =A1*2 into B1.

from Library.Workbook import Workbook

workbook = Workbook()
workbook.AddWorksheet("Sheet1")
workbook.AddWorksheet("Sheet2")
workbook.AddWorksheet("Sheet3")

Constants = {
    'Sheet1': {
        (1, 1): 1,
    },
}
Formatting = {}
workbook.Populate(Constants, Formatting)

workbook["Sheet1"].B1 = workbook["Sheet1"].A1*2

User Code

All the code generated from the model is divided among three uneditable sections in the coding pane:

imports and worksheet creation
constants and formatting
formulae

In addition, there are three editable sections for user code, one after each of the generated ones. The user code is "on the same rights" with the generated code which is creating the workbook to display; the merge is perfect :).

Buttons

That would have been all and buttons aren't strictly necessary to discuss here, but they fit quite well. A button can be created in the user code and set as the value of a cell. Of course a button has a click handler that a user would define as a function. This handler is not executed during the recalculation of course. So when is it executed, and more importantly what can it do?

The first question is quite easy. The handler gets called when user clicks the button. He can't click it until he can see it, which is after the recalculation is finished the workbook is displayed on the grid.

There is nothing magic in what a button can do. Python has lexical scopes, so the handler has access to anything that was in scope where the function was defined, in particular this means the workbook object. For instance, handler could create two hundred new buttons and place them all over the grid.

When a user clicks a button the handler is called after which Resolver One refreshes the grid to display any changes made to the displayed workbook. There is no recalculation, because the model didn't change. This also means, that any changes made by the button handler will disappear after the next recalculation is finished, because there will be simply different workbook object being displayed.

Note: Resolver One 1.4, next major release, will provide means for changing the model from a button handler.

Wrapup

So that is the architecture of Resolver One, brought to you by one of the programmers on the team. Every other feature in the application revolves around this foundation. Of course the model contains more stuff, for which code needs to be generated; but it all ends up in one of the three sections in coding pane. To fully grok different features in Resolver One, you need to understand recalculation.

Mailless mailing list

noreply@blogger.com (Kamil Dworakowski) — Wed, 07 Jan 2009 21:57:00 +0000

I was being flooded with messages from various mailing lists . I wasn't missing any personal mails, but I scanned through the inbox looking for more important mails, and the ones from mailing lists were almost always less so.

At one point I though that I could write an application to neatly track the groups when I realized that such an app already exists, it is called Google Groups. Quite a discovery, I know, thank you very much.

Your google account is fine with the service of course. You can easily subscribe to usenet groups, Google Groups native groups, or to proxies of Mailman managed groups like groups.google.com/group/ironpy, and receive no mail whatsoever (if you indicate so in group settings).

Ironpy was set up by Michael Foord. He set up the Google Group for the existing mailing list: users @ lists.ironpython.com. If you just subscribe to this google group, it serves as a sort of read-only view. You can try to post but the mailman want let your e-mails through. For this you need to subscribe with the Mailman. I thought that here ended my mailless mailing list project, but turns out that Mailman has a setting for not sending the mail, vacation mode it is called. Hence, from now on I'm on vacation ;). Brilliant!

Key workaround

noreply@blogger.com (Kamil Dworakowski) — Mon, 29 Dec 2008 22:59:00 +0000

When I was buying Lenovo ThinkPad T61, I was not aware of swapped Fn and Ctrl keys on its keyboard nor how much pain that would cause me. They placed Fn key were Ctrl should be. Needless to say that it caused numerous errors, where instead of Ctrl I would hit the misplaced Fn key.

I have found a satisfactory workaround that I want to share. I have sticked a piece of scotch tape on top of the Ctrl key. It gives me sensory feedback. It seems to have done the trick; I no longer inadvertently hit Fn key.

Note: originally I tried sticking it on top of Fn key, but for some reason it didn't work for me.

And one more thing, lenovo sux.

Hackage packages

noreply@blogger.com (Kamil Dworakowski) — Thu, 25 Sep 2008 13:26:00 +0000

People behind Well-Typed have published this graph yesterday. It shows packages on hackage. I have added links from all the circles I could recognize to the corresponding packages on hackage.

assert the machine did not explode

noreply@blogger.com (Kamil Dworakowski) — Fri, 08 Aug 2008 07:42:00 +0000

I see it often done by novices, heck, I used to do that myself. When writing a unit test for a method cloning an object, I would put an assertion to check that the original object is left unchanged.

Well, that is wrong. This is checking against a possible bug in the implementation, in which the original object gets modified. But this is just one thing that could go wrong. There are infinitely many possible bugs like this, maybe even one that causes your machine to explode. You can't write assertions against all of them, so don't do it against any of them.

It has two advantages. First is that you stop worrying you forget assertions against some possible bug; that is, if you were worrying about that in the first place. I am sure there are people out there who feel bad about not testing against printing foul language. Second is that the tests themselves become smaller, focused on the positive behavior, therefore easier to read.

In the specific example of cloning: check that the cloned object is equal to the original but they are not the same objects, and that is it. Nothing else.

Unit tests are positive tests, they should only test what you want the code to do, not what it shouldn't do. I am not sure about the case when we fix a defect, but probably a functional test for the defect is enough.

camelCaseSplit t i n g

noreply@blogger.com (Kamil Dworakowski) — Sun, 13 Apr 2008 17:30:00 +0000

Unit tests are whitebox tests. You want to have them cover all possible paths through the code. If a method has an if statement, you need two tests to cover the two possible code paths. When you remove the if statement, you can also remove one of the tests.

Changing code often requires changing tests, and when you have 3 to 1 ratio of tests to code, you want the tests to be readable. 80 character camelCase test names are not helping. You get used to reading camelCase but you will never get as fast in it as reading spaced text.

To write tests we use PyUnit framework, as it turned out the unittest.TextTestRunner would print the docstring for the method implementing test, instead of the usual ClassName.testMethod. The only thing left was to write a program that would go through our 120 000 lines of test code and put the split name into docstrings.

This is not ideal sulution, as it still requires unique method names. With HUnit and NemerleUnit you don't have this problem.

When defining new tests we are going to put only additional information into the docstring, trying not to exceed 4 components limit in the method name. Both class and method names provide information, what the test is checking. The docstring should be used as additional information.

I had to slightly modify the TextRunner to get this behaviour, printing the class and test name as well as the docstring, though. By default it prints only docstring, if there is any.

BTW, spaces were not introduced until 4th century AD. Plato was writing without them, for example.

GVim to convert code into html

noreply@blogger.com (Kamil Dworakowski) — Sat, 05 Apr 2008 23:09:00 +0000

Few are aware of the fact that gvim can generate html for the code inside the buffer. The command is :TOhtml; just type it in, and the html will promptly appear in a split window.

In the browser, the generated html should look exactly as you see it in gvim. By default it generates html that should work in old browsers too, but can be told to generate CSS stylesheets or even xhtml. Type :help TOhtml for more details.

It works only in gvim, though; not in vim. It is handy for posting snippets of code on the web.

Starting a new blog

noreply@blogger.com (Kamil Dworakowski) — Thu, 03 Apr 2008 21:21:00 +0000

It will be a diary from developing an application in Haskell. I intend to keep the posts clean and short. Initial post contains links to two papers. To the first paper I have already linked to from this blog, it compares Haskell with other languages. Second is a classic paper on functional programming, why functional programming matters, a highly recommended read. Here is a link.

.NET BCL source code

noreply@blogger.com (Kamil Dworakowski) — Sun, 02 Mar 2008 14:05:00 +0000

Source code for .NET Base Class Library has been made available for debugging sessions in VS2008. It would download one file at a time as they are needed. Since then John Robbins and Karem Kusmezer have create a tool to download all the source files without hassle, great work! The tool is NetMassDownloader.

Use it whilst it is still working :). Download, unpack, and run:

NetMassDownloader.exe -output bcl
    -d C:\Windows\Microsoft.NET\Framework\v2.0.50727

I executed in in Windows XP as a limited user and have seen numerous failure messages printed out. Nevertheless, 120MB of data was downloaded and I had all the files I wanted. The authors advise though to run it as a privileged process (at least on Vista).

The most interesting parts are bcl/redbits/ndp/clr/src/BCL/System and bcl/redbits/ndp/fx/src where bcl is the name of the directory you provided after -output switch. Together they are about 75MB.

It was pretty interesting to read the implementation of the classes I had been using for so long: String, Hashtable, Arraylist. They are easy to understand, with lots of comments, and of course in C#.

The classes I have read are all pretty basic and no wonder there are lots of pointers and calls into unmanaged code, but it is still readable.

One surprising thing, but obvious after knowing it, is that " s ".Trim() will not create a new string "s", but return a slice, an object that holds a reference to the original string and knows where are the beginning and the end. This is possible thanks to the immutability of strings. I bet the substring method is implemented like this too.

There are also some monster methods to be seen. One example is internal HttpListener.HandleAuthenticate spanning more than half a thousand lines.

BTW source code for mono is available at mono-project.com/AnonSVN. Source for mono's BCL is under mcs/class/corlib. It might be interesting to compare the two.

Why Vim's modes frustrate newbies

noreply@blogger.com (Kamil Dworakowski) — Sat, 01 Mar 2008 14:09:00 +0000

Some people say they hate the Vim's modes. Puzzling, because I consider the modes as the killer feature of Vim, something that makes it superior to Emacs.

Why modes rock

I spend most of the time in the normal mode. In this mode, undo is just u, delete line dd and move one word forward w. In Emacs these commands would all include ctrl, shift, alt or whatever. Inserting text is not what I spend most of the time in an editor on. Most of the time I need to quickly navigate around and make small modification to an already existing text. It is false economy to have the keys on the keyboard be bound to less often used functionality all the time.

When I reach the exact place where I need to enter some text, I press i to enter insert mode, type it, and immediately get back to normal mode (I get to normal mode by pressing ctrl-[ rather than ESC).

Why modes frustrate newbies

While pairing with people new to Vim I noticed that they leave it in whatever mode. So if they were inserting, they live it in insert mode. When they come back to Vim window (after inspecting results of a test run for example), they think they are typing normal-mode commands, but are actually in the insert mode typing text. Or the opposite situation: start typing and instead of inserting text they are rapidly killing one chunk of the file after another.

Experienced Vimers follow a convention. After doing something briefly in other mode, immediately go back to the normal mode. I never live Vim in the insert mode or any other mode than normal; when I get back to the Vim window I can always assume Vim is in the normal mode.

xmonad

noreply@blogger.com (Kamil Dworakowski) — Sun, 17 Feb 2008 15:40:00 +0000

I am running xmonad! I had some troubles configuring it though.

I am running Ubuntu Gutsy Gibbon and had to compile it from sources which turned out to be easy, but then the instructions to actually run it didn't work. I have finally got it going by following instructions in FAQ about using xmonad with a display manager.

Before I got xmonad working I tried wmii, which was readily available in repositories. After installing it (sudo apt-get install wmii) you can log out, and in gdm (session manager) change session to wmii to finally log in and enjoy wmii. wmii would be good for me had I no dual head configuration. It was treating my two monitors as one big virtual screen. This meant that a part of it was not visible to me as my left monitor is shorter than the right.

xmonad has much fewer lines of code that wmii. I have seen it a few times already, Haskell programs being very small in comparison with alternatives in other languages. wmii is proud to keep it small in under 10 000 lines of code, while xmonad is written in less then 1300 lines of Haskell. Additionally, there are 583 lines in tests. Not bad considering that xmonad turned out to be better then wmii.

I got these numbers by running the following command on ver 0.6 sources, it ignores blank lines and comments.

find . -name \*.hs -exec cat {} \; |\
    egrep -v "^ *$|^ *--" | wc

BTW xmonad is cool.

Time tracking

noreply@blogger.com (Kamil Dworakowski) — Wed, 13 Feb 2008 21:10:00 +0000

I get all those ideas and have no time to realize them. I just don't know where all the time goes.

When I started studying my parents were sending me a fixed amount of money for each month. But the money was running low so quickly that in the last week of each month I needed to ask them for more. That was slightly embarrassing, so I decided to keep track of my expenses to justify it. After a few weeks I was able to find a few "big wins", cutting down my expenses without affecting quality of life. From then on I was staying within budget.

Since people say time is money, I would like to try this technique now on time after it worked so good on money. I started noting how time I spend on stuff with a pen and notebook, before it occurred to me that there must be web 2.0 apps for this. There seem to be plenty, I started using two of them simultaneously to compare. The far better of the two turned out to be slimtimer.

It is a brilliant app. If you ever need a time tracking app, check this one first.

I am tracking my time for a week already, side effect is that I realized my excuse for not switching to Linux is groundless. After analyzing my last week's activities it is clear to me that I needed windows only for 2h total.It is my first blog entry published from Ubuntu Gutsy Gibbon and am looking forward to trying out some tiling window manager, I will probably go for xmonad just because it is written in Haskell :).

Writing this entry took 19 minutes.