replicator.org ... incoherent code

When I have phases of real progress that moves me forward, it seems that there is one pattern repeating: I am doing Micro-Iterations.

That is, I got a small problem while writing software and think about it, and if I have no solutions for, say 30 seconds, I stand up, go to my table, sit down and write the problem on a piece of paper. The physical shift in location and activity encourages me to get into a dialog with myself, largely supported by re-spotting the written words or sketches. And solutions flow in, one after another, bringing me forward in my thinking and writing.

It’s the discrimination, it’s the setup, the context that changes perspective and so initiates the rewiring. Software development was never in the code, the fingers or the language, it’s in our heads. Consciously separating an explicit “now I want to be creative” situation from the “typing work” may be an important behavioral pattern that makes us faster and more innovative.

My latest personal observation is that a lot of people and – importantly - myself included are driven by fear.

It’s not like the fear you would cry out loud, it’s more the softer type, influenced from the personal experience we’ve all made. It seems to me that a lot of decisions we make are not about progress, but trying to succeed without making mistakes. And there I see a fundamental problem:

Is it wise to avoid mistakes in the first place, even if a potential failure can be fixed at a later time? Aren’t we often tricked into a kind of “attribution error” regarding the future?

Can past experience really be applied to new projects?

There are two related quotes I like to mention:

Failure is an option, fear is not. - James Cameron

Premature optimization is the root of all evil. – Donald Knuth

and furthermore there is the DRY principle: Don’t repeat yourself.

So when every new project is different and every next requirement can be unforeseen, how is it then possible to see ahead based on our past experience?

I suspect that this fear is the “fear of the future” the outcome, the surprises, the unforeseen. Shouldn’t it be different?

We finally integrated our new license management, but don’t panic, alpha testers automatically get a Upload license installed that runs until the first of July.

There is not so much new in this release so far, but we prepared a lot for making SharedSafe a serious product. We created the first part of a complete product licensing infrastructure and are really proud of it. It does exactly what we need and is pretty simple to use.

So there is this new tab in the Configuration tool, I’ve showed you before in a previous post. After the installation of build 1611, there should be exactly one unpersonalized license:

And we have integrated new Application Icons, and we think, great ones, which finally match our product Logo :)

Besides preparing the website, the next steps are:

Notifications

I know how I can be happy. Do you know? And if so, do you live it?

There are practices that will lead to a happy life and – also important – to a good relation with one’s work. But the problem is – perhaps the most profound one – that we just forget about all these best practices most of the time. So with this post, I’d like to share my personal manifest that should guide my daily life:

Daily Work

Prioritize first!

One of the hardest mental tasks is to prioritize work, so this should be done at first in the morning. For me, prioritization is just finding out what annoys me most:

Do tasks that annoy you first.

Finding out what annoys me is not easy, but one of the most important tasks in my life to keep me sane. I try to ask that question every morning and try to fix the problems in the same day.

If there are annoying tasks that can’t be “fixed” in one day, I think about canceling it. Learn to say “no”. If it is a project and I assume it will be annoying tomorrow (because it was yesterday and the weeks before), it’s even more important to get rid of it.

Happiness depends on being relaxed and pleased after each day, otherwise our lives go into the wrong direction. There is no such thing like “but later”. Life is now, and we all know it, but social and environmental pressure keeps us thinking otherwise. Brains fear change, but change is almost always a good thing.

That leads to a simple rule: Never accept annoying tasks that take longer than a day!

Don’t trick yourself into getting a rose colored perspective.

One of the next steps in personal computing will be Personal Process Management: Programming for the end user.

Combine new tablet devices like the iPad with the ease of creating a concept map like Instaviz and the power of programming.

Graphical programming has been blamed for not being able to capturing enough complexity, but – for a certain types of applications – it is sufficient, if not a lot more capable, because it may blend the visualization of processes with their semantics and live feedback.

Why to use PPM

Personal Process Management is not an obvious requirement, but automating tasks, which are repeated over and over again, sure is. Here are some ideas:

• Home automation is one area that needs configuration and simple programming for which an tablet would be the ideal device.
• Email forwarding and sorting sometimes requires more than an out-of-office reply.
• News filtering and classification may be the killer feature to keep you up to date with less but more precise information.

There may be some advanced application areas. I can imagine to use PPM to configure routings for web-services, programming failover scenarios, and – in general – event routing, that defines what to do with all the events that reach you on your various devices.

The current state of user interfaces is disappointing in the sense they fail to scale. Put thousands of entries in a Listbox and expect a degradation of performance, put thousand nodes on the screen, and zooming stutters. Just one thousand and we need hundreds of thousands.

Virtualization is the pathetical attempt to improve the situation, spot-wise. Globally, when your favorite user interface once failed to build scalability in, the application developer must optimize the details, which is hard and often impossible.

What is wrong here?

Simple said, convert them into a document. A document that is dynamically formed while the user is entering data required to proceed.

Compared to Wizards, this has several advantages: All relevant information entered is visible at any time, and by entering more information, the document expands to form out the final result that contains a representation of all the previous choices.

There is no context-switch for the user, the page may scroll but valid data never disappears.

When users change their mind, going back to a previous page is not required, they just change the option and continue, the document reforms as data is entered.

This user interface pattern is named responsive disclosure, and I am a fan of it. Sadly it’s not so commonly used, probably because of the difficulties in implementing it.

Today I started integrating our license management tools into our new product SharedSafe (sry, there is no website yet).

The first plan was to integrate the License Manager user interface like the about box: placing a “License Management” button on the right of the “About” button, but then I got struck by a “too much buttons” paranoia and thought about directly integrating the license table into another Tab of SharedSafe’s Configuration tool.

It’s possible in .NET to reference and load Executables from another Executable, and because the LicenseManager user interface was already a Executable, it was trivial to create a Windows Forms Control from the inner part and reference it from the Configuration Executable. Here is the final result:

In my opinion, this is a much better solution than to pop up just another dialog.

Tomorrow I am starting to integrate the license checks and the Tray Icon notification that will appear when a license is missing.

Today I decided to move my blog from the self hosted Drupal installation to wordpress.com, but then I sticked with upgrading my Drupal installation and a blogging API so that I can author content from my Desktop Computer.

Things have changed lately and I wanted reduce all duties and focus on new products for my company. So getting away from Drupal was my goal for today, but it did not work out.

I like the style of Wordpress.com, the administration interface is usable (compared to Blogger.com) and the preinstalled theme rocks.

Uploading to Wordpress worked just fine using Windows Live Writer.

But – to make things more readable – I just wanted to change the font size, which is possible by editing CSS but costs $15. Somehow this is not right, I just wanted to improve the readability of my blog and I should pay $15 for? No, this price may be ok for more elaborate style adjustments, but not for changing the font size.

Then I looked for possibilities to convert my older Drupal posts to Wordpress. But I gave up after asking google for a while.

So I was setting up another free blog on Blogger.com to see what the alternatives look like. Windows Live Writer was able to post the same content without a problem.

It’s a shame that ClearType is turned on in WPF by default and does not respect the operating system’s settings.

While this may be a good default for large Fonts, smaller fonts look blurry and a lot like colored patchworks.

I personally prefer crisp, pixel aligned fonts. Reading ClearType rendered text distracts and annoys me.

WPF’s font rendering engine does not support pixel alignment, so the only option to make text more readable, is to switch off ClearType and hope that anti-aliased greyscale rendering improves the experience.

To change these settings, the registry editor has to be used. Here is an article that explains how to adjust the ClearType settings for WPF.

We need to change registry entries for that: Go to the registry editor, open the key “HKEY_CURRENT_USER/Software/Microsoft/Avalon.Graphics”. Here you will find a folder for each monitor:

Now, for each display, set the ClearTypeLevel to 0.

Switching off ClearType results in greyscaled anti-aliased fonts. The font is rendered with relatively slim stems, especially when vertical lines lie right in between two pixels columns.

Luckily, the contrast level of the text can be adjusted, too. Its valid values range from 1 to 6: 1 (the default) results in very slim text, 6 appears bold. For me, a value of 3 is perfect: small fonts appear bold, but they are now much better readable.

So, to finalize the registry settings: Set the TextContrastLevel to 3 (or some other value depending on your preference).

I hope this works for you like it did for me.

yours
armin