Done right it looks easy, but it’s not

When you watch kung fu in movies, or martial arts in general it makes sense logically, it looks sensible. Attackers punch in one direction and defenders block in another. Sometimes there’s tricks and special moves but they’re just a matter of learning them. However when you actually try and do these moves you find it’s not so simple. It’s not easy to react the right way under pressure when you’ve not done it before. You need to learn muscle memory, improve your fitness, work on your reactions and internalise sometimes counter-intuitive techniques. When you really do it well you use very little energy to do something that looks easy and it becomes easy but other people can’t get it just by watching you.

Both software engineering and kung fu are deceptively difficult, with hidden complexities and complex emergent behaviour. I think it was Grady Booch who said (although I couldn’t find the quote so any mistake is mine) “Software development has, is and always will be, inherently complex”.

Complexity built from simple small techniques

In many kung fu styles you learn basic small movements in repetition, often called “form” in martial arts, Sil Nim Tao (generally referred to as Siu Nim Tao in Wing Chun kung fu, the RUP of kung fu) is translated as “little idea form”. Learning this form we learn all of the basic movements and stances that set up the body positions required to get the mechanical advantage in a given situation. Each individual movement tends to be very, very simple.

This kind of information and learning is analogous to the basic software engineering knowledge that we give people. We teach them how to write in a language, idioms, patterns, standard architectures, frameworks, build technologies, iterative patterns etc.

However knowing which techniques apply in which situations, which play well with others and how to put them all together is another level of expertise based on experience. Teaching someone the basics does not make them a master. Software engineering, like kung fu is something you should never stop practising and learning.

It gets more complex when you add more people

Defending yourself from one attacker is a whole different ball game than defending yourself from two attackers. Defending yourself from a group of attackers breaks down the whole mixed metaphor of ballgames, sports and anything else in the vicinity. The complexity of the action increases significantly as you add more people, it’s not just a linear relationship. As more and more people are involved there are emergent behaviours that can’t be predicted from the beginning.

This is true of any activity that multiple people take part in, especially complex activities. In kung fu it means you have multiple attacks, more energy in your attackers which means once you’re tired you’re in trouble. In software it means you have multiple people doing things at the same time with subtly or radically different ideas on what should be done and the best way to do it.

The only ways to reduce this complexity in software engineering are to go up or down. We can either abstract away from the complexity moving to higher level technologies where possible (sacrificing fine control typically) although such abstraction tends to bring it’s own complexities or we can dive down and educate the team (in the broadest sends) on the complexities to try and reach a common understanding.

No plan survives contact with the enemy

Trying to plan in detail all of the details of a kung fu fight, even against a known assailant is about as pointless as trying to plan all of the details of a software project. There is too much uncertainty, too much complexity and too much emergent behaviour. Above all there is too much change. In both kung fu and software engineering we need to remain agile and responsive to change, in the environment, the different things being thrown at us and our own actions.

There’s no magical solution

We’re not in the Matrix, we can’t download kung fu skills into our heads in seconds. Or software engineering skills. These things take years to learn, will be slightly different for every individual as they tailor the standard wisdom to their particular individual skills and style.

There’s a lot to learn. Personally I work as a software development coach helping people structure and plan their work from architecture and design mentoring, SCM & Build techniques and tooling, requirements management, agile and iterative project management, portfolio and business management. In many ways these kind of things, and others similar to them, can be thought of as different styles of martial art. Just because you’re good at one of them doesn’t mean that you’re good at another, or the next new one that comes along. Of course a certain aptitude helps, and knowledge of one certainly makes others easier to learn but beware of “experts in everything”.

We can’t all be Bruce Lee, Jackie Chan or Jet Li but we get a choice about where we are on the spectrum between being a master and an armchair expert sitting on the sofa watching others do it.

Finally

I believe that there’s an exact art and subtle science to both martial arts and software engineering. We need to practice these skills, we need to be continually learning and improving. We need to learn from other styles and experienced practitioners.

“Kung Fu” is actually translated to “achievement through great effort”

If you’re in the Cheltenham, UK area come and do some kung fu with me at Chi Wai Black Belt Academy.

I’ll leave you to make your own Chuck Norris software jokes…

The WordPress.com stats helper monkeys prepared a 2011 annual report for this blog.

Here’s an excerpt:

The concert hall at the Sydney Opera House holds 2,700 people. This blog was viewed about 17,000 times in 2011. If it were a concert at Sydney Opera House, it would take about 6 sold-out performances for that many people to see it.

Click here to see the complete report.

If you’ve not seen it before, the MMD WordPress FireFox extension adds a tiny toolbar that shows you your current blog hits on your wordpress.com blog(s). You can then right click to get quick access to the full stats page, new post page and view your blob. Simple but quite useful. Download and install from mozilla

MMD WordPress Extension

Note that this is for the occasional user, if you’re a command line user by nature then just use the normal scm command line, it’s quite easy when you’re used to it. Using this script will involve the creation of an RTC repository workspace, since at the time of writing this can’t be removed using the command line you may wish to tidy them up using the GUI.

The script (available via github):

#!/bin/bash

rtc_server="https://your_server:9443/ccm"

echo ""
echo "Loads the contents of a component from a Jazz SCM stream to the current directory"
echo 'Usage: scmload "<stream_name>" "<component_name>"'
echo ""

stream=$1
comp=$2
error=0

if [ -z "$1" ]
then
  echo "Error: Please specify a stream"
  error=1
fi

if [ -z "$2" ]
then
  echo "Error: Please specify a component"
  error=1
fi

#generate a hopefully unique workspace name
workspace=my_cmdline_wks_$stream

if [ $error -eq 0 ]
then
  echo "Loading stream \"$stream\" component \"$comp\" into local workspace"
  scm login -c -r $rtc_server -n rtclive
  wks_created_str='scm create workspace -s "$stream" "$workspace" -r rtclive'
  echo $wks_created_str
  wks_success='echo "$wks_created_str" | grep "successfully created"'
  if [ -n "$wks_success" ]
  then
    wks_id='echo $wks_created_str | cut -d "(" -f2 | cut -d ")" -f1'
    scm load $wks_id "$comp" -r rtclive
  fi
fi

echo ""

Like I said this only automates a fairly simple set of command, but for a novice user it might be helpful as it takes parameters and wotnot. Here’s what it would look like using the plain scm cli:

scm login -c -r https://your_server:9443/ccm -n rtclive
scm create workspace -s "Stream A" "My New Workspace" -r rtclive
scm load "My New Workspace" "Component A" -r rtclive

I’ve always liked Wirthian languages since programming in Modula-2 and university and Delphi late because they’re very readable and promote good programming practices in the structure of the language. Also, I like Wirth’s law “Software is getting slower more rapidly than hardware becomes faster.” from A Plea for Lean Software even if it wasn’t actually him that came up with it.

When I made the jump from Windows to Linux I was on the search for a nice high level language to do GUI development stuff in. In searching I came across Lazarus. Lazarus is a free cross-platform IDE which provides the Delphi experience for Linux (and Windows). Rather than Java’s “write once run anywhere” Lazarus aim’s for “write once compile anywhere” courtesy of the Fee Pascal Compiler (FPC). On top of the compiler Lazarus comes with the LCL (Lazarus Component Library) which gives a single interface for GUI programming despite underlying differences in implementation.

Lazarus is at 0.9.30 so it’s not a v1 product yet… However I’m not going to give much benefit for that since it’s been around for both windows and linux since 2008 and is available from the Ubuntu Software Centre.

Installation

Oh dear… the most important part of a software package, since if it fails your software doesn’t get used and for Lazarus it just sucks! When I first tried to install Lazarus it took me over 20 times to get it actually working. A comment from the Lazarus forum replied: “…20 times isn’t that much…” as if this is acceptable. Ok, so it’s free and open source but if it’s not accessible people won’t use it. It’s so hard to get running I’ve posted twice on the topic (and had a significant amount of hits from people with the same problems).

Worse, upgrades to Ubuntu have totally broken the installation and it’s not properly compatible with the new Ubuntu overlay scrollbars leading to focus problems with windows, text boxes and menus.

Basically, unless you really care it not going to be easy to get going. 1/10

First Impressions

Once I finally got it running my immediate reaction was summed up by the word “w00t“. Despite the always ugly multi-window layout here was an environment and language I knew like the back of my hand (so long as I rewind my memory 15 years) and could quickly put together good looking cross-platform apps in

Normal multi-window interface for Lazarus

Lazarus as a single window IDE

It is possible (by recomiling the IDE) to get a single window mode which is a bit more modern. I was little disappointed to see that it didn’t have multi-project support but at least it’s solid and works if a little old-fashioned feeling. 6/10

WARNING: Due to problems with focus, the current version is close to unusable in Ubuntu 11.10.

GUI Designer

The GUI designer is solid and works well. Guidelines, alignment indicators and a pretty good set of visual components make putting together a simple form trivial. There’s no layout controls as you get in many newer GUI IDEs (flex boxes, tables, fixes vs.s flow etc.) but the use of anchors and panels means this isn’t a problem. The GUI designer feels a lot like the Delphi designer 9/10

Code Editor

The code editor features all of the old colour schemes and look and feel of Delphi with all of the modern stuff you’d expect like code folding, code completion etc.  The link between code and visual elements is easy to manage, especially with the excellent Actions feature. The Lazarus code editor is actually an improvement over the old Delphi editor 9/10

Language Features

Global variables are still there, I understand taking them out would cause problems for supporting old code bases but it’s still a shame.

The language is a good simple OO implementation but it misses out on some modern features like extension methods, anon methods, iterators, code attributes/decoration, multi-cast events…

Generics have been added but they feel a bit like a bolt on, especially as when compared to their simplicity in languages like c#. Here’s the same example I used in the c# mono review in Lazarus.

  generic TGList<T> = class
    Items: array of T;
    procedure Add(Value: T);
  end;

  TBlobList = specialize TGList<Pointer>;

....

  sb := TStringList.Create();
  for n :=0 to Length(blobs.Items)-1 do
  begin
    sb.Append(TTestBlob(blobs.Items[n]).name);
  end;
  Memo1.Text:= sb.Text;

Note the necessity to declare the details of the generic collection, and implement an ad method. Surely I’m missed something here, if I’ve got to actually declare the class and implement it I may as well not use a generic. If anyone can advise what I’m doing wrong here I’d like to hear about it

Also the need to typecase objects coming out of my list is ugly and old-fashioned.

Finally.. there’s no (limited) garbage collection. Although visual elements are dealt with when you close a form (it’s normally too late by then if there’s a problem) there’s no garbage collection wbich means in that code above I need to change the TStringList.Create to:

sb := TStringList.Create();
try
   ...
finally
   sb.Free;
end;

All in all, although it used to be a neat elegant language, and it still is Object Pascal just feels a bit old fashioned and clunky now. Sadly I’m going to have to give this 6/10

Feedback Process

The main feedback mechanism is the Lazarus site with wiki and forum. The forum’s fairly active but there seems to be an acceptance of problems such as the installation issues which is worrying.  7/10

Conclusions

Although the current version doesn’t really work with Ubuntu 11.10 the previous (and I hope future) configurations provide a pretty easy to use solid GUI design and code experience if a little old fashioned.

The community is reasonably active but a lot of the Lazarus usage seems non-English meaning the resources are sometimes a little hard to understand for me and since Pascal is  a bit of a niche language these days there’s not much non-Lazarus resources that can apply (except for old Delphi resources).

Although I’m predisposed to be positive about Lazarus to be honest I can’t really recommend it unless:

• You’re an old Delphi developer looking for some nostaligia
• Someone who hasn’t accepted Delphi is dead (even the website set up to refute this http://www.isdelphidead.com/ is dead!)
• You need to quickly produce something very simple for multiple platforms and don’t know any other languages

MonoDevelop 2.6 is awesome I first tried MonoDevelop about a year ago and gave up quickly. It just wasn’t usable, but these days it’s a totally different story. I’m quite drawn to Mono and MonoDevelop because I used to be a .net developer and really like C# as a language.  Also as an old Delphi developer the .net framework has an intuitive design and structure since they were both designed in large part by the same guy – Anders Hejlsberg. I saw him present on LINQ in LA, he’s a clever dude.

Mono is an open source project to make .Net compliant tools, compilers, runtimes etc. able to run not just on windows, but on linux, android, mac etc. MonoDevelop is an open source development environment for Mono providing GUI designers and language support for C#, Java, Boo, VB.Net, Python, Vala, C, C++, Oxygene (Object Pascal based .Net language, though not available in the current version of MonoDevelop).

Installation

I was able to install it directly from the Ubuntu Software Centre, it ran straight away with no issues. Not quite 10/10 though. I tried to write a “hello world app”  and  it wouldn’t compile A quick google later and I found that the default .net framework target in the project options needed changing from 2.0 to 4.0 then it was fine. 9/10

First Impressions

Starting up MonoDevelop you’re greeting with a very MS Visual Studio like welcome screen with links to create stuff, recent stuff and web links. The IDE has a very solid and elegant feel, it doesn’t start with a million views and tabs like Eclipse, is visually pleasing (unlike Lazarus) and incorporates platform theming well (unlike Eclipse/SWT). 10/10

MonoDevelop Welcome Screen

GUI Designer

The GUI designer is embedded in the main window in a similar fashion to MS Visual Studio, with widgets in a toolbox controlled by layout containers (fixed, aligning, tables etc.). Widgets are added to a window by drag and dropping and although there’s nice to have features like alignment guidelines missing the designer is solid, platform themed and doesn’t crash. It slightly frustrating to me that I can’t just double click on a button to create a default click handler and start writing my code but I can double click in the signals box (on the right) and do it from there.

MonoDevelop GUI designer

Brilliantly, it can handly some old c# .net forms I wrote which used custom visual inheritance to make a new form frame for an unusual app which I assumed would break it!

The only downside here is that many of the properties seem oddly named and aren’t consistent across different types. I keep having to hunt around for where to find the text property for different objects. There’s little relationship to WinForms either if you’re using GTK# in terms of property and event names. Oh yeah, and alignment/guide lines aren’t there yet when dragging components around.

Putting together a simple form is a trivial matter completed in seconds. 8/10

Code Editor

The code editor supports all the normal modern stuff like colour control, code folding, code completion etc. and again is neat and elegant. The code completion helper in particular is very easy to use as is the code snippets tool box. Obvious problems are underlined as you type and the link between the visual elements and code is easy to work with.

MonoDevelop - Code Editing

MonoDevelop - Code Errors

The only downsides for me are the refactoring interaction which features a visual arrow that jumps to suggested places to put the new code – it doesn’t jump to very sensible places sometime; the compilation errro/warnings which are shown inline embedded in the code. These can make it a little hard to read the code until you’re used to them. You can of course turn them off. Overall though, it’s excellent. 9/10

Language Features

Writing C# in mono is brilliant. From the mono project website:

The Mono C# compiler is considered feature complete for C# 1.0, C# 2.0 and C# 3.0 (ECMA). A preview of C# 4.0 is distributed with Mono 2.6, and a complete C# 4.0 implementation is available with Mono 2.8…

That means the language supports OO constructs, iterators, anon methods, generics, statics, extension methods, LINQ, memory management, reflection, threading and much more…

Between LINQ and the mono framework implementation of the powerful MVC pattern loading stuff into object graphs and presenting that in editable for to users is a high level programming exercise.

As an easy language example here’s  working with a collection of TestBlob entities:

private List<TestBlob> blobs = new List<TestBlob>();

...
StringBuilder sb = new StringBuilder();
for (int n=0;n<blobs.Count;n++)
{
      sb.AppendLine(blobs[n].Name);
}
....

Simplez!

10/10

Feedback Process

There’s a little feedback button on the bottom of the IDE that lets you quickly send feedback to the community. I did this regarding my frustration over clicks from the visual designer direct to code handlers and another minor issue. Within the day I had a friendly response describing how my comments had been listed as two bugs on the public bug tracking system on xamarin.com and explaining how to add myself as a subscriber should I wish it.

MonoDevelop - Feedback

That’s awesomeness on toast! 10/10

Conclusions

The solid GUI designer, integrated debugger and high level language support for cross-platform development provided by MonoDevelop is brilliant. It’s easy to knock up a quick app to do something. My 7yr old son and I have been using it do develop a calculator as an introduction to programming basics and he things it’s a good easy to use system.

Getting going with the MVC pattern can be a little frustrating if you just want to programmatically put a bunch of things in a listview (btw if you do this use a treeview not a listview even if that sounds crazy at this point) but that’s a common hurdle for most modern day languages/gui widget sets.

The mono and monodevlop communities are large and active and the web is full of c# tutorials and info. I’ve found that guidance written for MS developers in c# is directly applicable to c# in mono. This is now my favourite cross-platform development environment and technology.

Google Ngram Viewer shows graphs of how many times words or phrases have occurred in a set of 5 million books over the years. They’re a really interesting way of seeing trends in information and relative importance between words. It’s free and easy so check it out.

Here’s some I recently ran that I found interesting. I ran most of them from 1950 onwards and  the info only goes up to 2008.

Comparison of programming languages

Programming Languages

Ngram link – When looking at this you’ve got to mentally remove the baseline Java and Pascal references from the 1950 as they’re about coffee, islands and mathematicians. Interesting to see Java so dominant.

Programming paradigms

Programming Paradigms

Ngram link – I found this one really interesting. Compared to the others in my query “structured programming” had a lot more books written about it. I wonder how much this is a reflection of the rise of the internet… these days although there are lots of programming books the primary source for learning a language is online material?

Methodologies

Methodologies

Ngram link – I was a little surprised to see RUP so much more prevalent than agile but then I did have to add “software development” to the term to avoid including the bendy and stretchy. Also as with the previous one I suspect that there’s a difference here between a vendor driven process with supporting books and a more open source philosophy on agile as a generic umbrella for methodologies, and therefore more online sources. As Ivar Jacobson says: “No one reads process books“

Shareware, Freeware and OSS

Shareware, Freeware and Open Source

Ngram link – This one speaks for itself I wish I could have worked out how to add “expensive vendor products” to the query!

User Stories vs. Use Cases

User Story vs. Use Case

Ngram link – Ah yes, this argument again. Interestingly this dominance of use case over user story in written books correlates with query stats between user stories and use cases on by blog and the ivarjacobson.com site. Personally I think they’re both great and complimentary, I often use them together on software projects.

Windows vs. Linux

Windows vs. Linux

Ngram link – Yep, Linux beats Windows at every turn.

More Ngrams!

For more fun with Ngrams watch this very funny video explaining this stuff

1. Totally remove previous Lazarus and fpc installations

sudo apt-get purge lazarus*
sudo apt-get purge fpc*
sudo rm -Rf /usr/lib/fpc
sudo rm -Rf /usr/lib/lazarus
sudo rm -Rf /usr/share/fpcsrc
sudo rm -f ~/.fpc
sudo rm -Rf ~/.lazarus
sudo rm -f /usr/bin/lazarus*
sudo rm -f /usr/bin/lazres*
sudo rm -f /usr/bin/lazbuild*
sudo rm -f ~/.local/share/applications/lazarus*

2. Install fpc so you can use it from the command line

sudo apt-get install fp-compiler-2.4.4

You can see if this has worked properly by writing a hello world command line app, comiling it and running it before you’ve even tried to install lazarus. Save the following in a file called cmdline_helloworld.pas:

begin

writeln(‘hello world!’);

end.

Then compile using

fpc cmdline_helloworld.pas

and run using:

./cmdline_helloworld

Free Pascal Compiler use on the command line

3. Install lazarus

sudo apt-get install lazarus

You probably need to disable overlay scrollbars otherwise you can get problems using menus and dialogs in Lazarus and apps made with lazarus:

export LIBOVERLAY_SCROLLBAR=0

if you don’t want to make such a global change then just make a script to start lazarus like this:

#!/bin/sh
LIBOVERLAY_SCROLLBAR=0 lazarus-ide

4. Change IDE settings to make it easier to use with Unity

Unity is annoying for many reasons, but it doesn’t deal with multi-window apps like Lazarus very well. So here’s some suggestions to make it all behave a bit better.

First, if you use a taskbar plugin like tint you can have Lazarus only show one button rather than loads on the task bar (Environment -> Options -> Window and slect “Show single button in Taskbar” at the top.

Second, I recommend making lazarus use single window mode. This is a little experimental but I think it’s a major improvement over the old-fashioned pre-Delphi 2005 layout.

Normal layout:

Normal multi-window interface for Lazarus

To transform Lazarus into a single window mode application you need to install the AnchorDockingDsgn package which is helpfully installed with Lazarus. On ubuntu in a standard installation it’ll be in /usr/lib/lazarus/0.9.30/examples/anchordocking/design.

Do this as sudo otherwise the recompiling process doesn’t have enough rights to backup packages and wotnot. So start lazarus by doing

sudo lazarus-ide

In Lazarus File -> Open and browse to anchordockingdsgn.lpk

When the package editor comes up select the install button. Lazarus will ask for confirmation and tell you only static packages are supported so you need to rebuild lazarus (that really needs sorting out!), say yes and then sit back and enjoy the compilation process.

Next time you start Lazarus it’ll be in single window mode. For some reason the Object Inspector (F11) isn’t docked by default but you can easily add it yourself.

Lazarus as a single window IDE

I read recently that the UK Govt is considering a move to double sumertime, which it’s important to point out has nothing to do with double rainbows. I can’t quite make my mind up about it in terms of this change, it’ll make it easier to work with Europe but put use yet another hour away from the US.

I don’t see why we need to do it at all. Like Income tax, Daylight Saving Time (DST)  was introduced during wartime and never repealed (ok, that’s not entirely true, income tax was repealed and reinstated a few times as wars came and went, the last time it was reintroduced was to deal with a defecit in 1842). I don’t think we need to change timezone at all, if people in some industries want to use the daylight more then why don’t they personally adjust their sleeping patterns? I’m rubbish at dealing with time zone changes, jet lag and sleep generally. Changing DST just tires me out and makes me grumpy.

I’d like to see us dump DST entirely and just stick with the same timezone all year around, like the Russians are doing. Let’s look at the impact of dropping DST in Russia and then see if it’s worth doing here too.

/rant

I had an early invite to UNTHINK when it opened to public beta, clearly along with many other early adopters. First problem there, the servers couldn’t handle the pressure, there were too many early adopters and without the power of Google behind UT (not the best acronym huh?) the public beta was essentially a fine example of  a DDOS attack.

Anyway, a couple of days later and here’s my first impressions, now I can access the site.

UNTHINK

First of all I find it be gloriously complex. G+ has catered for the simplistic market, but I like complicated things, and this suits me. The UI is reminiscent of the early Facebook and MySpace.  G+ allows me to separate people via circles but I have to set that up, UT has it from the start. It’s all private by default and they tell me I own my content (the unthink emancipation deed). UT prompts me from the very start to control the privacy options of my content, unlike Facebook which decides for me frequently. Finally, it reminds me of uplink for some reason, and that’s double or possibly even triple awesome

But… the social networking market is saturated. Facebook is the Daddy Mac, it’s where everyone is. Some of my techie friends still aren’t on G+ so that’s quiet. UT is positively empty. I keep coming back to Facebook because it’s where people are, many of my friends have no appetite for multiple networks and as with G+ I wish I could cross post with FB.

Whether it catches on or not, it’s existence is a good thing as it will apply pressure on widely adopted networks to provide better features. It wasn’t long after the exposure of G+ circles that Facebook created “Close friends” and “Acquaintances”.