To those who were there, this is classic stuff, to the rest of the world it will be meaningless even if I try and explain so I won’t. (And I wasn’t even there.)

The old Uboot has been replaced by a new Uboot today, and what better way to celebrate the old uboot than the re-release of the official language guide.

The original Wörterbuch mysteriously went offline, but I knew I had to somehow find it. It couldn’t die. It had to be saved. It has taken some effort to find and save; I’ve been searching for it on and off for the last few months.  In the end I had to guess URLs on the internet archive, until I found an old copy of http://www.aezpskin.com/. However this didn’t have the content, but “view source” revealed a “CMS location” which the Wayback machine had mangled to point to itself but it couldn’t serve (as it was was dyanmic). So i turned the CMS link into a non-Wayback web link, then replacing www. with sms. (prefix for old uboot) and some Javascript appeared on my screen which contained the content.

Last week I went to the doctor about a stomach problem. There was a small nasty room, there was a queue of standing people. The woman at the desk was only serving people one person at a time, and only serving them once the doctor had finished with the previous person. So we stood there for about half an hour, I was feeling reasonably dizzy due to my problems, there were old people leaning against the wall as evidently standing for 30 minutes was too much for them.

Finally I got to see the doctor, she invited me to explain my problem. As soon as I started talking, she was typing stuff into her computer from the previous patient, reading an sms, and not listening to me. So I just stopped talking (I can’t stand talking to someone when I know they’re not listening). A minute or two passed before she looked at me and said I need a particular test. I doubt this test will bring any benefit, given she hadn’t listened to what I was saying, and I stopped talking half way through explaining my situation. But just on the off-chance it will help, I’ll go anyway.

She read off a list of things I wasn’t allowed to eat the night before. Basically I am only allowed to eat rice in the evening before the test. I mean, that’s fair enough, if that’s what the test demanded. She told me them incredibly quickly but I tried to memorize them as best I could. When I got home I immediately wrote them down, I managed to remember at least half of the things I had to avoid, I think, so that’s something.

She had given me a telephone number to get an appointment. I rang it the next day, and the incredibly rude lady on the phone told me I didn’t need an appointment, I should just turn up.

Today I rang to ask a question about the appointment which I was intending to go to tomorrow, the woman told me, also incredibly rudely, “well I can’t just come by, I need an appointment!”. So now I’ve got an appointment for next week. She told me another set of things I can’t eat, which are quite different to the list the doctor told me. I can only eat bread and a few other things until 6pm, after which I’m not allowed to eat anything.

I mean, I’ve no idea if what she’s told me is right. I mean assuming she’s right, that means the doctor was wrong and the person who I talked to the first time (saying I didn’t need an appointment) was wrong. If the doctor was right, that means the person I talked to the first time was wrong and the person I’ve just talked to was wrong.

I asked the woman I’ve just talked to if this information was available online or in printed form, but she said it wasn’t. So really, next time I ring up, or when I go there, I mean it could be completely different again. I mean I think the chance of the situation being identical to what she told me (and therefore different to what the doctor or the first person told me), is pretty much close to zero.

Should I ring up multiple times, and go to multiple doctors, and average the result? Or should I go to e.g. 10 doctors, and if 5 tell me one thing and the other 5 tell me 5 other things, I should go with the thing that the most doctors have told me?

If my doctor was wrong about the test, and I take the test results to my doctor, do I trust her to be able to interpret the results correctly?

Will my doctor even listen to me?

Will I have to wait 30 minutes again standing up next time I see my doctor? (At least this one is reasonably predictable, I’d say with 90% certainty that’s a yes.)

I just don’t know what to do.

I don’t want to criticize the country I’m living in, and seem ungrateful… Austrians I’ve met have been very proud of their health service. I’ve never really been to any other health service (apart from a private dental clinic in Macau/China which was excellent – competent, clean, one could sit down while waiting, and cheap.). But I think the quality of service, and attitude, is really very poor at the doctors I’ve been to. And everything takes a long time, you need appointments which take weeks to get, so you’re left being ill for a month or more.

I only went to this doctor because I’m fed up with every other doctor I’ve been to in Austria (quite a few). When I had a problem with my toe (in-growing toe-nail), the doctor pressed it so hard (so that the oversized sharp nail was pressing into the infected oversized red flesh surrounding it), I couldn’t sleep that night with all the pain (resulting in me sending a very frustrated email to my colleagues at 4am saying I wouldn’t be coming in.). After many weeks of seeing me he finally referred me to a specialist who was shocked that “I’d left it so long to see him, this is badly infected and needs to be treated immediately”. Also, the specialist never applied force to the toe-nail, I mean his strategy for healing it wasn’t just to press it with all the force his body could muster.

If there were doctors who I could pay, who are better (e.g. don’t have to stand while waiting for them), then I will find them, and pay, and use them. Obviously I’d rather have doctors for free (given that they’re not free, and one pays an enormous amount of mandatory tax to have their free service available), but I mean what is money sitting on my bank account for, if not to avoid me having to put up with this sort of stuff.

I am not one to demand luxury, anyone who knows my flat must believe that, but that waiting room where I stood for 30 mins, was just one of the nastiest rooms I’ve been into in the last 10 years.

There is a great debate in C-style languages about the position of the asterisk and the space when declaring pointers:

MyType *x; // Original C style
MyType* x; // The other style

I was reminded of this when attending an Objective-C training course recently. Apple’s tools create declarations of the first form, the trainer preferred the second form. I remember having an opinion on this debate back when I first came across the second form, good to see that debate is still alive and well.

The logic for the second type is that x is a “pointer to MyType” and therefore one should separate the type (MyType*) from the name of the variable. That would make sense however the syntax of C doesn’t work that way. The line

MyType* x,y;

is confusing, it appears to imply that both x and y are pointers to MyType. I have read many times that this is dangerous, and the solution is never to declare more than one variable on a line.

However in fact it’s not dangerous at all, and one needn’t remember an arbitrary rule to remove this danger. The star is in the wrong place, and that’s where the confusion comes from. If one writes the statement differently:

MyType *x, y;

Then it becomes clear that only x is the pointer and y is not a pointer.

Therefore, I must side with Apple’s tools as opposed to our trainer. One has to use the syntax as it was intended, and it was intended that the type is adopted by all variables in a declaration, the level of indirection (pointers) however is not. As that’s the case, and cannot/will not be changed, the level of indirection (the number of stars) must be next to the variable name, and not the type.

In my opinion, to write the star next to the type should be a compile error.

I’ve just got back from a 4-day course on working in teams (“Erfolgreich Zusammenarbeit im Team” by Coverdale for my employer s IT Solutions).

First conclusion -> Top food at Hotel Wende in Neusiedl am See.

I am so tired now, it was much more tiring than I had imagined it would be. Lots of “exercises” which really required a lot of concentration, especially if one was to learn the maximum possible from them. I must admit I went into it not expecting much (it was a mandatory course) but I tried my best anyway and did actually learn more than I thought i would (i.e. more than zero). (It did start a bit like S01E04 of the Office UK, I must admit..)

So here are my learnings, in no particular order -  (as much for my benefit in the future as anything else)

• Individual creativity. If you ask everyone in the room for ideas, once the first person suggests an idea, everyone tends to discuss and build on that. If you ask everyone individually to write ideas down, in silence, then you have a much greater range of suggestions.
• Need for moderation in meetings. In the exercises, it became clear that without a moderator / leader, the subject would wander randomly, and away from what should be discussed. This is rather obvious, but seems to contradict “scrum” (or at least the way it’s done where I work), where the belief is that if you put a range of people together, they’ll “work it out” and magically great ideas will be formed (instead this leads to “design by committee”).
• In meetings, write on a whiteboard not on paper. When dealing with a common idea, I am the one who tends to write the things down. Although it sounds obvious, I had never really noticed that nobody else can see what I’m writing it down. Writing the same thing on a white-board means everyone can see what’s going on and can comment on it.
• Dealing with blocking people. When dealing with people who are excessively negative and blocking in meeting, where no one can suggest anything without being shot down by the “expert”, it was suggested to try and actively split the process into two parts (1) Creation and collection of ideas, (2) Feedback/Risks to those ideas. I shall give this a try.
• If a new team member joins your team, try and treat them as equal to the existing team members as soon as possible. I certainly welcome when this is done. (I caught myself saying I was “new” the other day, although I’ve been at the company for 9 months. I wondered why that was. I realize now it’s because the people who’ve been there longer guard their role, don’t treat new people as equals, therefore I still feel new.)
• Write not only the answers but also the question on the white-board – When writing answers to a question on the white-board, if you don’t include the question (i.e. just ask it verbally at the start of the meeting) people forgets that the answers increasingly don’t fit to the question as the discussion progresses and the topic wanders.

I had the situation recently where I needed a “button”; when the user clicks the button, then:

• An “svn up” should occur, to update some XML config files + data files (CSV)
• If the config files or CSV files have errors, the operation should be aborted and an error printed
• If correct, the CSV data should be imported into the database ready for processing
• If correct, the config files should be made available for use

The config files are a bunch of XML files; each file has a complex structure, and they themselves are in a complex directory structure. One option would be to put them into a database as well but I felt that a simpler solution was just to leave them on the disk where they could be parsed. Directories, files and XML files more naturally fit the hierarchical nature of the configuration in question. I didn’t want to have multiple representations of this configuration (one being directories/XML; the other being a database).

This is all OK, but how to make all of that (config files update + database work) atomic? i.e.

• If anything goes wrong, the entire operation fails and rolls back with an error message
• If it succeeds then the entire operation succeeds
• If the server crashes, then an update was either successful or rolled back (but nothing in between)

I came up with a nice solution:

• A database transaction is started
• The “svn up” process programmatically connects to the Subversion server and does a brand new checkout into a directory with a random name (i.e. actually “svn co” not “svn up”).
• The XML files are parsed and checked; if there is an error, the operation is aborted
• The CSV files are loaded into the database within the transaction, if there is an error, the operation is aborted (& rolled back)
• The new random directory name is written into a table “current directory name”, also in the transaction
• The transaction is committed
• Each time access is needed to the XML files, a lookup is first done in the table to retrieve the directory name, the files are then read from this directory.

This has the consequence that:

• Either the “commit” occurs and the new XML files are “live” (table points to new directory name) and the CSV data has been imported
• Or a “rollback” (or crash and auto-rollback) occurs in which case the CSV import is rolled back, and the table points to the old version of the XML files which are still on the disk

I’m pleased with this solution :-)

One should really also write a clean-up script, deleting directories which (a) aren’t in the database and (b) were created a certain amount of time ago e.g. a few days. That way old directories, or directories checked out which had errors or failed, are removed, but directories which are in the process of being checked out are not removed.

P.S. Allowing the user to submit new versions of the data by checking it into Subversion is a nice idea:

• It’s a bunch of structured data (bunch of XML and CSV files in a particular directory format)
• This is easy to visualize with Windows Explorer and TortoiseSVN
• This would not be easy or nice to do with multiple <input type=file> file upload buttons
• The “svn co” command in the software is easy; there are various libraries for programmatic access to SVN: I used svnkit: I found it well documented, seemingly bug free, it just worked first time.
• Obligatory link about why I didn’t use Git ;-) (the person involved can use TortoiseSVN but wouldn’t have been able to handle git)

Sometimes it’s valid to have tables that reference one another. For example:

• A photo table stores photos, each of these photos belongs in a folder
• A folder table, but each folder has mandatory (not null) “cover” photo

So both tables reference one another, but how do you create the tables, and how do you insert data?

• If you try and create either of the tables, the other would need to exist in order to create the table with the foreign key constraint. The solution is to firstly create both tables without the foreign key constraints and secondly “alter” the tables to add the foreign key constraints.
• If you try and insert a photo, the folder would need to exist; if you try and insert a folder then its cover photo would already need to exist. The solution here is to create the foreign keys with “initially deferred deferrable“; then the foreign key constraints are checked at commit-time rather than insert-time. You can insert the rows, in any order, and only when you do a commit will the system check that the constraints are not violated.

A perfect explanation here:
http://infolab.stanford.edu/~ullman/fcdb/oracle/or-triggers.html

A few weeks ago I got really into stackoverflow.com, the question/answer site for programming:

But now I’ve got a bit bored of it. If you want to achieve reputation, it seems you have to take the following things into account:

• People will only vote up your answers who are able to see that your answer is correct; therefore common topics or easy topics (such as simple SQL questions) will get more votes and therefore reputation points than something which requires more detailed knowledge such as Oracle optimization tips or Lucene full-text search indexing strategies. (Example of a popular answer, example of non-popular answer)
• Obviously once a question has been correctly answered, there’s no point in answering it again. Therefore people tend to surf the newest questions, looking for things to answer. Therefore if you answer a really old question, even if it’s still valid and hasn’t been answered, nobody will see it and vote up your answer and you won’t get points.
• People looking at a question, if there are 3 of 4 answers, they will vote up one of them if they are correct. If yours isn’t there yet, you don’t get voted up (yet). Therefore you have to answer quickly. Answering quickly is probably the exact opposite of answering in a reflected and considered way, with a lot of detail, etc.

So basically you have the situation that, in order to gain points, you have to keep on refreshing the “newest questions” page, find a really easy question which anyone could answer, and then answer it in a really non-detailed way.

But still, for a week or so, I was obsessed with my status. So it’s been definitely a good learning experience for me, that “game mechanics” with arbitrary rewards (which don’t cost the site owner anything) can really get your users to get obsessed with whatever you want them to do and make them do free work for you (in this case, build up a set of questions and answers on a website, which does have value to the site owner).

I have been working self-employed for s IT Solutions since 1 March 2010; from 1 September I’m salaried there. (I shall still be doing bug-fixing for my old customers, consultancy, and perhaps some smaller new development projects on the side. This is explicitly allowed in my employment contract.)

s IT Solutions is the IT provider for Erste Bank and the Sparkasse Group. My role is in the team doing the Internet presence of those banks (e.g. corporate homepages; has more software of a greater complexity than one would perhaps imagine..) and the online banking services for those banks (which has as much software as one would imagine..)

It’s the first large company I’ve ever worked for. Every other company was either a start-up or had grown from being a start-up. Obviously there are a lot of differences, but I have to say there are both advantages and disadvantages to both options. Working at start-ups one gets a lot of marketing that working for large companies is really bad, that everyone would rather be working for a start-up, “doing something they love”, and that those of us who manage to make it into the start-up world are those who have had the courage to make the move, “fire the boss”, and we look in pity at those who haven’t had that courage; examples 1 2. I’m pretty angry about myself having believed that marketing unquestioned for so long.

My experiences with large companies are obviously incomplete as this is my first large company, so I can’t really tell which properties are properties of only this company, and which are properties of large companies in general. But the benefits which have become obvious so far as:

• Food – Perhaps this has the most impact on my daily life ;-) The food is really excellent, and only costs €3.40 for soup, salad, main course, desert and fruit. Better than microwaved stuff from the shop, or going to a restaurant and spending €10.
• Variety of people – It’s nice to talk to different people with different backgrounds and experiences (obviously easier if there are more people to talk to), there is a greater range of older and younger people.
• Higher salaries – At least this seems to be the case. By some philosophies at least, this makes one feel more valued, although how sound that logic is, I’m not so certain. But on a purely practical level, obviously more money is good.
• Fewer salary discussions – At a few places I’ve worked, there have been some students, who have been really talented, and earn e.g. €19/hr. It’s inevitable then, if one earns more, there are going to be discussions from time to time about why one earns more than them. I am fed up with such discussions.
• Less unnecessary pressure – If one is ill, having a bad day, or whatever, there are more people who can take over from you the larger the team.

And some disadvantages:

• More specialised roles – Whereas in smaller companies I’ve done requirements, software design, programming, deployment, performance analysis, live bug fixing, a certain amount of sysadmin, here everyone has more specialised roles.
• Can’t access Gmail or Facebook etc. at work – This has disadvantages above and beyond just not being able to surf. Those two sites are really the leaders of web usability, not only in terms of their innovation but also in terms of their adoption. As a consequence, people at larger companies, if they don’t use those sites at home, are not necessarily familiar with the current trends in web usability.
• Ridiculous VPN software – Most of my small-company customers are hosted at (or are) Nessus, they always set the systems up so that they are simultaneously secure and very convenient to log in to (e.g. ssh directly, test servers via https) so that VPNs were not necessary. I guess commercial VPNs succeed/fail solely by their marketing to bosses, as opposed to how convenient the employees find them, and thus the VPNs evolve consistent with these environmental demands.
• Less choice of OS – I don’t mind working with Windows but I know that’s not the case for everyone.

Some things are the same:

• Source code beauty – I have worked on two projects here, one more beautiful than the other. The code quality at the small companies I worked at also varied greatly. I assert code quality and company size are orthogonal dimensions.
• You always have a boss – I have had good and bad bosses at small companies. I get on well with, and respect, my boss here. But no doubt there are bad bosses in large companies too. Therefore I further assert that how much you like your boss and company size are orthogonal dimensions.
• Difficulty of the work – You can choose your jobs/customers based on any number of attributes of the potential assignments, for example salary, difficulty, location of the office, and so on. Very rarely have I had the luxury of seeing an opportunity which is both extremely challenging, and well paid. While the work here is “just programming”, most of the work I’ve been doing in the last few years has been “just programming”, and I think one can make a big difference for the customer by doing excellent “just programming”, so I am more than happy to do that.

And this consequences which is an advantage/disadvantage depending on your viewpoint ;-) (but in my view an advantage)

• Not blindly applying frameworks - At least the group I’m in, they don’t blindly follow software trends, but are also not inflexible either. I have had a lot of bad experiences with certain Java frameworks (all at small companies, obviously). Using simple programming, without thousands of XML config files, has advantages in terms of performance, maintainability, reliability (bugs), and IDE being able to do refactoring.

So the main thing I’m trying to say is I believed assertions, by startups, that only startups are good, for 10 years of my life, going to no effort to actually verify or refute them. This was a mistake, which I regret.

In Javadoc there is an @author tag so you can specify who originally wrote the class, method, etc., being documented.

/**
 * This represents a user of the system as stored in Oracle.
 * @author Adrian Smith
 */
class User { ... }

But really, what’s the point, when version-control tools such as “svn log”, “svn blame” and exist? (And any project where it would be necessary to determine the author necessarily involves more than one person, any (at least) any project involving more than one person requires a version control system.)

• The information in version-control log is always accurate
• The information in the source file might originally have been accurate, but the class may have been heavily refactored by someone else
• Some people start classes by copy/pasting another file and changing it: the tag will be wrong in those cases (the people who do that aren’t going to be the people who read/write/update doc)

I suppose there could be a case for using @author in the cases that the source is distributed without any version control information. But at least on the projects I work on, that’s never the case.

The project I’m currently working on has random @author tags all over the place, due to various copy/paste action and refactoring. The @author tag bears no relation to the person who last changed the code, who knows about it, or even who’s still in the company. Wrong documentation is worse than no documentation, as you might be tempted to believe wrong documentation.

Java supports checked exceptions. Many people have strong opinions about if they are good or bad. I believe they are good, but let’s agree that Java has them and they’re not going away.

(Any exception extending “Exception”, which can to be thrown from a method, must be declared at the end of method’s signature, and any caller of the method must handle the exception or itself declare to throw that type of exception; Any exception extending “RuntimeException” need not be declared on method signatures. A programmer is free to choose which superclass to extend when designing their own exceptions.)

There are two ways of dealing with tasks which should be run in the future, both of which are very inelegant w.r.t. checked exception handling.

• Runnable – the task (method) may not throw any checked exception, as the “run” method does not declare any checked exceptions (as “Runnable” defines the method; and the interface, provided by Java, cannot know what exceptions your code may throw)
• Callable – “Solves” the problem with Runnable in that the task/method may throw a checked exception. To achieve this the interface declares “throws Exception” meaning any checked exception may be thrown. This means the caller must handle “catch Exception” i.e. handle all checked exceptions, which again gives you no safety as to which exceptions can actually be thrown (the purpose of checked exceptions in the first place)

(In addition, the difference between these two interfaces is solely the way they deal with exceptions. But you wouldn’t know that, or know which interface uses which strategy, by looking at their name!)

What one would need would be to extend the generics system to deal with exceptions. For example:

interface Callable<V,E> {
    V call() throws E;
}

class MyException extends Exception { .. }

class MyCallable implements Callable<MyObject, MyException> {
    MyObject call() throws MyException {
        throw new MyException(); // ok to throw, signature declares it
    }
}

void usingCallable(MyCallable e) {
    e.call(); // error: must catch MyException
}

The generic parameter “E” would have to be a list of exception classes as opposed to just one class.

Update: I was surprised to find out that using generic parameters for checked exceptions is basically supported! However it still isn’t very useful, as:

• There is no way for the generic parameter E to be a list of exceptions
• Callable/Runnable interfaces provided by Java do not support it
• All the useful ThreadPool code that comes with Java support only Callable/Runnable