So let’s say there are 10 Boolean conditions involved in the decision, That’s 2 to the power of 10 or 1024 different cases. Resulting in a very long question and answer session. Luckily in most case one can simplify the decision a lot by combining hole groups of cases. E.g. if the first three parameters are true, the other seven conditions might not matter anymore. While this shortens the Boolean expression,it also makes it really hard to understand what is going on. You are now stuck with a Boolean expression where one has to look very precisely in order to determine which case applies and what it results in.

In my experience many Boolean problems in programming don’t actually need the full complexity of Boolean expressions. An example: Enabling or disabling a button that represents an action on a domain object. Here are the conditions that apply for enabling the button: If authorization is activated he user needs the privileges for that action; the domain object needs to be of  type A, B or C; if the action is state dependent the domain object has to be in the appropriate state. Although these are only a couple conditions, the resulting Boolean expression can become quite involved. And don’t even think about adding rules later on. But if you bring it in the structure I call ‘Boolean Stack’ it becomes rather easy and transparent.

A Boolean Stack consists of two sets of rules: allowing rules and denying rules. The result of the stack is true  if at least one of the allowing rules is true, and none of the denying rules is true.

So in the example above the allowing rules would be:

• The domain object is of type A
• The domain object is of type B
• The domain object is of type C

And the denying rules would be:

• The user has not the required privilege
• The object has not the correct state

Note that for typical changes in the conditions: new Types that support the action, Actions that are  not state dependent rules get added or removed from the set, instead of manipulating the Boolean expression itself.

Using this structure complex Boolean expressions become easy to understand and to maintain. I have used the structure for things like enabling / showing controls in a GUI as in the example, but also for deciding if a train may leave a station, which is at least in Europe controlled by literally hundreds of rules and conditions, which differ depending on the state the train starts and to which state it travels.

I am wondering if every Boolean condition can be transformed into this scheme. I actually think so, maybe I’ll find time to proof (or disproof) it some day.

I published before an OracleNamingStrategy that fixes this problem by creating abbreviations on this blog. But writing a new blog entry with all the code every time I find a little glitch in the code felt just wrong. So I published it as an official Open Source Project over at google code: The Hibernate Naming Strategy for Oracle! And I just released the first version. and since it is so extremely simple, it isn’t even a jar but a single java file.

I’d be glad if this is of some use for other developers. If you like it, drop me a line in the comments. If you find a bug or have an idea for improvement use the issue tracker.

• a plugin for your preferred IDE to create database migration scripts based on code changes on JPA annotated classes. So if you rename a field in a classs it would rename the matching column. If you add a field, it would add a column and so on. In the second version it should support refactorings on these scripts, like merging a drop column and a create column to a rename column script and vice versa.
• an iphone app that allows to make measures with the iphone. If you accelerate the iphone from a starting point and stop at some other time one should be able to calculate the distance travelled from acceleration and duration. I’d be curious what the size of the error would be from that kind of measurement.
• an iphone app that works like an sonar. You would produce a ping with a speaker and analyze what you receive through the microphone. From that you might be able to estimate the size of the room you are in. Of course you may as well look up from your iphone.
• another iphone app: take a photo of your poker hand, and a photo of the board and get the odds for your hand calculated.
• visualize a class diagram in a 3D graph and use a wii remote and the technique shown at TED to convey the 3D impression.
• a PL/SQL language plugin for eclipse (or any other decent IDE), with the usual support for refactoring and the like.

What are your ideas for software projects that you just haven’t enough time for?

Use different logging hierarchies

Why? Well Stephan writes in the first article:

Logging in web applications is important – to know what’s going on, for performance tuning and incident analyis.

So what do you do if you have performance issues in your system? You change your log level from WARNING or ERROR to INFO. So you get more detailed information. But now you get tons of logging that you are not interested in. In most logging approaches I have seen there is only one logging hierarchy. Normaly based on the full class name. But which class is responsible for performance related logging? Most of the time there is none. But one could easily use a prefix to differentiate between various aspects of logging. I’d like to propose these logging hierarchies:

no prefix: the normal technical logging used for debugging and exception logging

TIMING: logging of performance relevant information, i.e. time elapsed between start and end of method calls. On DEBUG level this is reported for every method, on INFO this is reported on all public methods, on WARN on all calls that go between packages and on ERROR only on calls from outside the controlled code and to remote resources (database, webservices and so on). Once the application runs stable you should get a baseline from this.

SECURE: logging of security relevant information: failed logins, creation of users, access of invalid urls, input values that look like some kind of XXX-injection, spikes in the number of requests. In this case the log level should control the thresholds on which logging appears.

AUDIT: logging information about completed (or failed) business transactions. This might be overkill for applications that work on a single database. But the application I am working on right now consists of about 50 pieces of hardware and a similar amount of various software pieces. It would be awesome if we could have a logging that basically says: Node A thought it completed a transaction but the transaction never apeared on Node C so we probably have a problem in Node B between A and B.

USER: logging information about user behavior. Invalid Data entered. Actions used. This should be an awesome source of information about which features work, which don’t and what pieces are really confusing for the user. With this I obviously do not agree with

Only log technical exceptions not user exceptions

For implementing these different loggers AOP comes in handy and you absolutely should look at MDC. Go figure

Any other logging hierarchies one should consider? Leave a comment.

Yet sometimes we can’t help it and just have to use PL/SQL for performance or political reasons, but it really hurts.
And the frustrating part: Nobody seems to care.

Nobody? There are a few guys working on these things. I wrote about Tim High before. Yesterday he left a comment on the post to inform me that he wrote another article that might interest me. Completely superfluous. I already picked it up on DZone and marked it for future reference in my blog. So here it is:

Test Coverage Reporting on Oracle 10g

Tim uses the data from the profiler to gather line coverage data and even puts it in a very nice report.

While beautiful in the result it is a tough way to get there with many scripts and some requirements on the code style. But its “better than nothing” as the saying goes in northern westfalia. So my next project which requires more than trivial PL/SQL code will get code coverag. Isn’t that great?

Apparently Tim worked together with Oracle on this so there is the very slight chance that Oracle or Toad or their competition will realize that there is a difference between a GUI for easy SQL hacking and a IDE that allows controlled software development.

Sure it would be no fun to think about some 100 coding rules and guidelines for every line of code you write. It would be slow a tedious and would take forever. But that’s not the way it is working. All the good developers, the pragmatic programmers do stick to the rules. But they don’t do that by actively thinking about the rules, they just learned the rules until they became their second nature. And only in difficult corner cases do they actively think about the rules, consider which one applies and if it might be one of the cases where you should break the rules. The problem is many developers do not know the rules and they will never learn them because nobody tells them I they don’t ask.

This should change. I envision a future where programmers are trained just as a craftsman. When you are trained as carpenter or welder, you get to do really simple things. Like joining to pieces of wood or metal or making a cube exactly 5cm big. And when the angle is straight or if it is 5.1 cm big or if it has some ugly scratches you throw it away and start over. And if your join is perfect and the cube is perfect you throw it away and do it again. Until each and every join and each and every cube you make is really nice and clean. And only then you get to do these things on the real job, until after a couple of years you know all the skills all the tricks you need to work as a craftsman. During a large part of that time you work for some really experienced master whose main task is to train you and maybe 10-20 other apprentices.

Compare that to the education as a developer. At least in Germany there are three ways to become a programmer:

1. You teach yourself and find a job. No formal training. It is pure luck if you found the important rules that really help you and prevent nightmares for the customers
2. You study computer science and get a job as a developer. You probably know how a parser and a compiler work, how to proof an algorithm correct and how a Turing machine works. But chances are that you never did a branch in some kind of version control. If you did you probably did it in your spare time and not at the university.
3. You get an apprenticeship. In this case you probably know how to do simple programs like a calculator. You wrote the calculator application once. And the source code sucks big time, but nobody told you as long as it works.

In any case very few of the new developers know even the simplest rules like:

• Use a version control system.
• If your code needs a lot of comments it sucks.
• Singletons are evil, most probably don’t even know the singleton (anti)pattern.
• …

What is the reason for this? Non developers can’t judge software. When a table is not well made you will notice pretty quickly. It will wobble and finally break. But if software is a big ball of mud inside, you won’t notice. Sure it has bugs, but all software has bugs. And it is expensive to change it but you don’t have anything to compare it to. Therefore junior developers or people that want to become developers get to work on real customer projects without any real supervision. Hardly anybody looks at their code, nobody tells them the rules and they don’t have the time to train the rules.
So how should education for future software developers look like? Teach the rules. Give them easy tasks: Implement an algorithm; implement it using an iterative approach; implement it using recursion; implement it in java; haskell, lisp, fortran, groovy; make it as fast as possible; make it as small as possible; make it as easy to understand as possible; make it scalable for hundreds of processors; write tests for it until they reach 100% statement coverage; break the implementation of some other student without breaking the tests; write test until they reach 100% path coverage; break the implementation of some other student without breaking the tests; Train the use of version control, build tools and the like with the same approach. Check every single result a student creates. If it doesn’t follow the rules let them do it again.
I think it is obvious that the IT-industry would be better off, when people get a lot of supervised education in programming. This seems to cost a lot of money, but I actually think it is a business idea! How about this:
Start a private software development school. Since you need the best teachers you get fees will be high. Arrange for scholarships by big IT-companies or let the students pay via some credit scheme where they pay only after they finished school. Come up with a strict curriculum. There is plenty input available. Also have a look at high end (military) schools. They don’t just teach the main subjects, but also general knowledge and physical training is mandatory. So this as well as creativity, presentation techniques would find their place in the curriculum. Pick your students carefully and kick those out that don’t meet the requirements. So why should people give you big lumps of money for this? How about a promise: “If you finish school here we guarantee you an offer for a job with a salary of at least X$. If not we pay you 50cent for every $ difference” I am pretty sure, a school as sketched could promise that without too much of a risk.
What do you think? Would you consider such a school as a starting point for your career in software development?

It really sounds like a trivial thing, but it isn’t. So far I have three times accountered scenarios where tests couldn’t possibly become red. And in all cases this went undetected at least for some time:

• The first time I finally found the problem, when I by excident ran code coverage not only for the code under test but also for the Tests themself. I was quite surprised to find many classes with partial coverage as well with no coverage at all. The partial coverage turned out to be ok. This was due to tests checking for thrown exceptions. Those resulted in segments of the testcode that where never run. But the Tests that never ran at all, well they never ran at all. They were not included in any test suite.
• The next time we were using Teamcity to run our tests on each commit. We were kind of proud of ourself, because the tests where green for quite some time now. We clicked around in the statistic a little just to show to ourself how great we were. But what was that?The number of executed tests wen’t down! Two days ago it went from 396 to 387! Who the heck deleted the tests? Well nobody did. But a change in the code caused an exception during setup of some tests. And this exception was silently ignored by Teamcity. But the associated tests of course didn’t ran, thus reducing the test count. JetBrains is aware of the problem, but it doesn’t seem to be high on the priority list.
• I detected the last on when I tried to gather some code statistics for a project and didn’t get any results. In this case no tests where run at all! The team used the ant junit target with the batchtest nested element. But the pattern they used was wrong. So no tests where picked up. But since no tests failed the build was reported as a success.

All cases where pretty trivial to fix, but also in all cases the not excecuted tests surfaced some problem when they where finally executed. So do yourself a favor and make sure that

• your tests can fail (test first is one way to do that) .
• all your tests do run (using code cover and examination of statistics)

And only than make sure that your tests stay green.

So today instead of mainly complaining, I’going to make a proposal on how to manage you database in a modular fashion.

One of the strengths of databases is the concept of foreign keys, a declarative way of enforcing relationships.
But when it comes to modularity, foreign keys are the source of all evils. They link two tables with each other and there is no standard way to remove the dependency. In object oriented computing languages this would be done with interfaces.

Instead of Class A directly referencing Class B it would reference a nInterface IB and Class B would implement that interface. We now can replace Class B and Instances of Class A won’t notice. How can we achieve this with databases?

Probably the first idea that comes to mind is “views!”. Views are basically select statements with the name. They do hide dependencies to the underlying tables so that is a start, but they do not correspond to interfaces for two reasons.

First: The dependency between a table and a view is just the opposite way than the dependency between a class and an interface. This means we can’t reference views in our code and simply swap the underlying table.

Second: At least Oracle (and I guess this is true for most databases) can’t use a view a foreign key relationship.
So views don’t help that much.

Let’s look once more at classes, interfaces. One thing to realize is that in the example above there is  a dependency between Instances of A and B but not between their classes. The dependency between the instances is created at runtime. How does that help with databases? Typically classes are identified with tables and instances with rows in tables and that works just fine for ORM tools.

But I want to propose a different mapping. How about considering the create script of the table “the class” and the actual table in a database a instance. If you choose this approach, everything falls into place. The interface becomes a create script that just creates the most essential columns of a table, possibly only the primary key. You now can have different implementing tables / scripts, which either add columns for your normal production version of the table or a more simple version with only a couple of fields. Or you create no additional fields at all.

Obviously this makes organizing the scripts more complex in the first step. What are the benefits? Actually this can help in many ways.

You can use it for testing. With database testing a common problem is the setup of test data. Since everything is connected with foreign keys you need to create tons of master data in order to just create a single row that you actually want to use in your test. Know you replace all tables referenced by the table you want to use in the test with dummy implementations, featuring just the primary key, so no further dependencies and the setup can happen easily, possibly automatically.

You can use it for a modular application. Imagine an application that references some kind of ‘Order’. One customer wants an extremely simple order with just one line item with a fixed quantity of 1. For another customer it is the average order with multiple line items, different units of quantities (string is sold by the meter, other stuff is sold by piece …). The third customer has extremely complex orders with rules governing what combinations of line items can go into a single order. You know this kind of order when you ever configured a car online. The forth customer has a different kind of order, but that doesn’t matter because it is a third party system and your application has just to maintain a reference.

Normally you need a table structure that combines all possible implementations, making it more complex than even the most complex implementation that you actually need. With the proposed approach you’ll have four different implementations and can choose the one you need for each deployment.

So how do we actually do this? Well that is the real challenge. Right now I don’t know of any tool supporting this. One could use Hibernate with a dynamically created Configuration. But there are things in a database that you probably don’t want to control via hibernate (e.g. partitions and tablespaces). You could create your own little script assembly tool, store DDL scripts in a directory structure, that has branches for each implementation variant. A little configuration file would define what implementation variant to use for which object. In any case we would need to stop developing directly in a database. We should work on the file system and deploy into a database even in development instead.

I guess there is plenty of room for more ideas and of course tools. What do you think? Is this an approach that could pay off? Is this old stuff and I just reinvented the wheel? Or is all this completely stupid and should be handled differently?

Although Office has many bugs and is a major case of feature bloat, but up to now I always stood up to defend it, because most of the stuff I use works ok, and that is probably more than 90% of the Office Users use. AND alternatives aren’t really there yet. Ok there is Open Office but the last time I looked at it, it was horrible, ugly, buggy and IMHO only usable for private use.

But now the ribbon enters the room. At least in the way it is implemented in Office it is the biggest usability road block short of a system crash. But first what is this ribbon thing anyway?

The ribbon is a GUI Component which replaces the menu bar and the toolbar found in so many applications. It looks like this:

(Click on the image for a full size version)

At first sight it looks just like a menu bar + a toolbar with different size icons and other elements in it. But this is a misconception.

• The menu bar is not really a menu bar but tabs, which one uses to switch between different toolbars.
• There is an additional thingy on the top which contains some actions like save, undo and redo called the Qick Access Toolbar:
  
• The is a big ugly bubble like icon which is actually a button, which is more or less the file menu:
  

If you are a developer there is also a document for you which describes, how you are supposed to use the ribbon component in the applications you create.

So what is wrong with all this?

Let´s start with the minor annoyances:

The more important commands in the Ribbon should get larger icons. Great. Just nobody asked me what is important for me. For example the different layouts you can view a word document with are NOT important for me. For me the whole concept of different layouts for viewing cut go away. I wouldn’t miss it. It actually would be an improvement, because it would stop word from opening documents ‘for full screen reading’.

Who had the weird idea that a two column menu (like the windows start button or the ribbon application button) is a good idea? It is probably the same guy that came up with the idea to add two buttons and a weird extra panel to the menu. Why there aren’t just three more menu items labeled ‘Recent Documents’, ‘Options’ and ‘Exit’? I have no idea.

But now it is getting serious, at least for me. For me toolbars and menus had two very distinct purposes: Toolbars where for quickly accessing stuff. Since I mostly use keyboard stuff for thing I need often. I don’t use toolbars to much. Menus are for looking up commands that I know are somewhere, but I don’t know the shortcut. In this case I look at the available menus, pick the one that sounds promising, and scan all the items in it. This approach completely fails with the ribbon!

Microsoft completely messed up the grouping of commands.
The design guide says explicitly:

Avoid arbitrary command placement. Suppose that you think you have a good tab and group design, but discover that several commands just don’t fit in. Chances are, your tab and group design isn’t as good as you think it is, and you need to continue to refine it. Don’t solve this problem by putting those commands where they don’t belong. If you do, users likely will have to inspect every tab to find them—then promptly forget where they are.

Yet every single office app has a ‘home’ tab which is just a glorified ‘other stuff’ which contains arbitrary stuff. But even within the proper tabs things are of: What has recording macros to do with ‘view’? Why is stuff named ‘… layout’ not in the ‘Page Layout’?

Even when the grouping of commands would have been done properly Microsoft did a great job at making searching the commands hard. With menus searching all items in the menus was really easy: Start with the first menu, go through it item by item. If an item is a submenu, continue with that submenu. When you finish a menu, go to the next menu. If you finish with a submenu, continue with the next item of the parent menu.

For the Ribbon the whole thing got way more difficult. First you scan the application menu. Don’t forget the two buttons in the application menu. Then iterate through the tabs scanning each toolbar within that tab, carefully checking the buttons for tiny triangles, which denote some combo box like control which hides even more commands. Ok scanning the cluttered toolbars, with text, icons in two sizes and all kinds of other controls is way slower than a nice list of commands/submenus but that isn’t too bad, isn’t it. Well it would be if we hadn’t missed 50% of the commands. Have a look at this partial screenshot.

Below the buttons and stuff is another grouping. It is completely useless since your eyes are coming from the tabs and get stuck between the buttons and controls before they notice, after a long search, that their search might have been easier if they had noticed the groups below first. What is more important is the tiny square with an arrow which is in some of the groups. It opens another dialog which sometimes looks like a menu and many actions are hidden in there.

So this is it, my rant about the Microsoft Ribbon Component. I actually don’t like rants. I like my blog posts to contain some useful stuff. So what are my recommendations?

If you plan to include a Ribbon in your next application think twice. It will look modern, but it will annoy users like me. You could make them happy with an option to replace the Ribbon with a more traditional UI. If you want to make users like me really happy make your menus searchable. In Java you can do that really easy with the substance look and feel it creates a search box for searching the menus all on its own … really nice.

Einreichungen, die alternative, partizipativere Formate
verwenden, werden bevorzugt. Wenn die klassische Vortragsform gewählt wird, dann sind
uns auch hier unkonventionelle Stile lieber.

(Proposals with an alternative participating format will be preferred. Even if a classical style is choosen a unconventional style is preferred)

Also the type of talks they are looking for sound interesting:

• Fishbowl – die für jedermann offene Podiumsdiskussion
• Expertenbefragung
• Blitzvortrag
• Open Space

Maybe we’ll see us at the conference that looks behind the buzzwords.