I like working at a university. I like solving problems without known solutions. I like improving existing solutions. I like working in my own directions. I like working with students. I like advising students with their work. I even like giving lectures.

However, what I don’t like, at least currently, is writing publications of my scientific results, which, of course, are the primary part in preparing a scientific career. This process ist currently awful, tiring and frustrating.

This year I wrote six articles. Each time I invested much work into preparation and presentation. However, *none* of them will be published this year. Not a single one. I never had such a bad year before. And from a realistic point-of-view, this is like a death blow for an accademic career.

Of course, this is not nice in itself, but what is even more frustrating are the reviews with which my articles got rejected. One of my papers hat numeric scores (1 = worst, 5 = best score) of: 4 + 4 + 3 +3. Also, the reviewer’s comments are sadly often nonprofessional, useless, and even polemic. Another paper was loved by two of the four reviewers. The third one found it borderline, but found it could be improved. The forth and primary one, however, worte something which I can only understand as “I don’t like it”. His review had more text but not much more contant than that. Result: rejected.

I had some discussions about this issue of an overcritical reviewing with several professors. All were aware of this problem and all agreed that this happens once in a while to a community. Sadly, in my opinion it has gotten continuously worse in the last seven years I have been working and publishing (except for this year) in the visualization community. Honestly, I don’t known what will be …

For several years now, I write my smaller tools in C#. I like the language and the runtime framework is powerful. For that matter I do not care about platform independance. Or for Mono. I am a fan of Windows Forms. It is a nice and capable GUI tool kit, close to the traditional c++ world, but with good abstractions at the right places. And then, there is WPF.

I do not know what to think about WPF.

On the one hand, Microsoft claims WPF to be the future. Many new functions are introduced (first or only) to WPF. Windows 8 Apps and Windows Phone Apps require the programmer to use WPF for the GUI. The data binding is nicely done and cleanly integrated into the language, compared to Windows Forms.

On the other hand, WPF is not a perfect solution. The performance is not great, if the GUI gets complex or heavily modified. The editor integrated in Visual Studio is not very good. (Okey, there is Expression blend, but I do not like to use two editors for one project at the same time.)

What realy bothers me, however, is that even Microsoft has no clear policy concerning this issue. Visual Studio 2012 is written using WPF and this is the required GUI toolkit for Apps. However, for example, the new Office, although sharing the new Metro design, does not use WPF, but uses classical GUI toolkits recreating the same look-and-feel. All in all, I just do not know which one to bet on, Windows Forms or WPF. Probably, it really does not matter at all. But, somehow, I do not like the current situation.

Drat! I wanted to write a post each sunday. Oh well. I will try to minimize these slips and I will try to catch up as quickly as possible.

The news: The TheLib project now uses a Subversion repository!

After Mercurial failed to proof its value, our eagerness for experiments had dried up. We thus switched to a system we knew it worked and how it worked.

Of course, there are countless projects happily working with Mercurial and, of course, there are countless good reasons why everything would be better using Git. To be honest: I don’t care.

Some time ago I fret about Mercurial. My opinon on that has not changed since then. The conversion tools are still ridiculously bad and the fact that no development group is interessted in SCM protocol interoperability is pathetic.

Nevertheless, I want to talk about Mercurial again. During the last weeks I worte some (scientific) texts together with several co-authors. These texts were controlled by Subversion repositories. I have to say: It did work perfectly!

Additionally I am working on a small (or maybe medium-sized) code project. There I create a library which is used by several persons by now. This is part of my working project VICCI. For reasons out of my control there is only one single subversion repository for all subprojects in VICCI and there is a globally dictated directory structure making it impossible to set up the usual “branches” and “tags” subdirectory for my project, because of external dependancies. This is … painful. I really should make some changes of the API of my project, but as it is now, I cannot do this without either not commiting unfinished code for some time or without breaking code of some of my colleagues. Of course there are solutions which only break everything for a very short time and which make everything better after that. But it is amazing how difficult it is to change something as soon as the group of people involved has a certain size. Whatever. With the current state I will not be happy.

A nice technical solution would be multi-protocol interfaces to repositories: i.e. a hg- or git-repository with interfaces for all: hg, git and svn. This is possilbe (see my conversion-tool-rant). Just, no one is doing its. *sigh*

It is again time for posting? … Time flies.

During the last days I kept wondering about software engineering. Somehow it is quite unsatisfying. Programming is a hard, tiresome and longsome work. I takes foreever. A program with the complexity of “Hello World” requires, if we are honest, roughly one week, I believe. No kidding. Of course, you could code this in 10 minutes, but if the programm needs to do something as absurd as processing input to generate output, then there will be countless details. Every one claiming “Whatever, I am gonna make it in an instance” makes himself/herself unbelievable and disqualifies himself/herself for working on larger projects. Sadly, this is still true for myself as well. I still tend to dramatically underestimate the time software needs.

The worst thing, however, is that you will not see the software consuming time. You will put weeks and months into a software. And looking at it from the outside you will not see any progress. Of course, at one point-in-time there will be a “click” and almost everything starts working, but it is a long way there.

So, how about RAD? My experience with RAD is that it is ok for small GUI-Programs. However, if the planned functionality is to large or to complex you quickly reach a point in RAD where it gets harder and harder to introduce the missing functions. You complete like 80% and then you have to fight for every new function to work correctly with the rest. The only way to avoid this is to produce a good foundation for your software. And there we are again: writing software which consumes a lot of time without providing early visible successes.

Well, whatever. This is the way it is, it seems.

Did I complain about software development, again?

I’m so fed up!

Half the weekend I am trying now to convert an hg repository into a svn repository. It seems to be the direction no one else needs, because hg (or git) are soo much better and greater that no one needs svn anymore and no one needs to convert to svn. *Not a single one* of the tools out there are working. Any my hg repository really is not that complex. The tools break at tasks as difficult as failing to delete a file because it does not exist. You cannot be serious!

You can accuse me (righly) to be a Windows fanboy. Why not. I like that OS and I am realy more and more convinced of Windows 8 the more time I am using it. Like this week again:

Each software is aging. (Somehow) This is a fact. Whether this is bit-rot or if software was never ment to be used, I don’t know. But, OS’ are no exception. At the times of Windows 95 it was pretty normal to re-install your system bi-monthly. And, before the first Linux fanboy now cries: Linux is not better in that respect. We use Ubuntu at work. Just by “not using” the computer at all, hardware configuration settings change and break themself. Great. However: this is not a flame against Linux. In this aspect all systems are stupid.

Early this week I experienced a massiv drop in IO performance on my Windows 8! After klicking a file I needed to wait several seconds before the program, which was already running, noticed that something happend. I never found out who to blame. (The last thing I had installed was an Update for Java.) I even was afraid it could be signs of a coming hardware failure. However, based on my experience: It is always the software to blame.

So, I tried out the new Windows 8 feature “refresh your PC” (re-install lite). I am totaly excited. Now the computer flys again. Ok, I have to reinstall my programs and I forgot to back up the settings of two of them. However, my system is clean now. I like it.

This weekend I took some work home with me. I am working on an implementation of a code library for research prototypes. However, during the week I can hardly make any progress. There to many different tasks for me to do (e-mails, meetings, funding proposals, reports, etc.).

Yesterday, I literally took the existing source code apart and started rewriting the internals. Why is it, that you always need to write 60% of a program, before you understand how to do it correctly? Year, I know the software engineering drill. I am an experienced software engineer myself and I know how to develop good code. But nevertheless it does not work. At least it does not work if the program is to complex, or gets to complex because I want to be ready for(already known) future uses. It feels like a special version of Hofstadter’s law: A software design has always problems, even if you consider all problems you know. It really would be a lot easier if software could stink. Then you would know when something goes into the wrong direction.

The development of TheLib continues.

One thing I learned during my work as developer of scientific software is that large software projects at universities are extreamly difficult to manage. Mainly because the people involved are “scientists” and no “developers”. The experience, the processes, and the structures to reach common goals (compromises) are mostly missing. At the same time, many problems of todays sciences cannot be solved without large and complex software. Thus, most software created in academia is pratically not usable. This is a fact I can not accept.

The approach of TheLib is based on the idea of “divide an conquer”. Instead of developing a huge software which can do everything, we concentrate on a clean development of smaller pieces of the software. This way, we can increaste the usablility, the maintainability and thus the re-usability of these components. The TheLib provides fundamental base classes. I see this project as “extension” to existing projects like the STL or BOOST. It is not a competitor and it does not aim to be one. Therefore, we pay close attantion to reach very high interoperability with these projects.

Even so we reduced the scope of the TheLib to a moderate minimum, it still is a lot to do. Whatever. This is how it should be. If it would be easy, anyone could do it. ;-)