A while ago I wrote a review of Lazarus 0.9.30 and it came out with the 63% mainly because the installation process was so horrible. Well now it’s almost a year later and v1.0 has been released so it’s only fair I update my comments…
It’s still not exactly shiny but, and it’s a huge but, it is simple and it works! 🙂 To install on Linux I had to download 3 .deb files (1 for Lazarus, 1 for the compiler, 1 for the source) and then I could install them by simply doing:
doing sudo dpkg -i *.deb
It’s worth tidying up any old Lazarus installs first which you can do by running my script here.
Downloading *.deb files and installing them is pretty normal for linux users so although it’s not a shiny wizard installer or single command it is simple and most importantly it just works! I’m going to upgrade this from 1/19 to 8/10
A lot of the little niggles have gone away and it’s a much more stable, solid feeling environment. It does still load up with a million windows (Delphi style) and feel a little old fashioned (a lack of wizzy GUI controls and UI customisation, single window mode etc.) but being open source and written in itself I can change these things if I want to reasonably easily. In fact loading up the AnchorDockingDesign package makes the IDE a docked single window affair and there’s plenty of 3rd part controls to download and play with.
There’s still no multi-project support and recompiling the IDE to get a new component on the toolbar feels a bit weird even if it does work perfectly well. I’m going to stick with 6/10 for those reasons.
The GUI designer and Code Editor haven’t really changed since my last review and so they stay happily at 9/10.
The handling of generics has improved since I last looked at Lazarus and all seems to work pretty well now 🙂
Otherwise nothing much has changed, no multicast events or garbage collection but those things don’t really slow me down much. That’s why I gave it 6/10.
Despite the lack of some of these things the language has always been and still is quite elegant (other than the nasty globals), it’s got an excellent simple OO implementation and it’s really easy to quickly put an app together – oh yeah and it’s cross platform.
Cross-platform and backwards compatible
Lazarus works on windows, linux and mac. You can write a bit of code and natively compile it on each platform making for lightening fast code with no external dependencies. Write once, compile anywhere. You can already (partially) compile for android and other platforms are possible – anywhere the fpc compliler can be ported your code could work. That’s pretty impressive and it just works brilliantly.
Similarly all that ancient Delphi code can be loaded up edited and compiled and largely just works. Brilliant again. For that reason I’m going to bump up the language features to 8/10. (9 when android is working well).
I’ve not tried the feedback process again since v1 so I’m going to leave it at 7/10.
Despite it’s old fashioned feel in some places it’s simplicity is elegant and actually quite powerful. If you know the Object Pascal/Delphi language then it’s so fast to create good looking cross platform apps that it’ll knock your socks off.
When I pick up a new language I tend to do a challenge to load an xml file into a multi-column listview and create a details form to edit the selected row. In Java, something so apparently simple is a massive pain due to the imposition of the MVC pattern on everything. In C# it’s pretty easy, I can go MVC or not. In mono it’s reasonably easy too, although not the same easy and not as easy to get away from MVC.
In Lazarus it’s really easy, and it works fast and well on 3 major platforms. That’s a killer feature.
|Overall||81% – Easy to use and powerful
In my previous review I said I couldn’t really recommend it, and that made me sad. Now I can recommend it, in fact it’s quickly becoming my technology of choice for linux gui development, because it’s quick to put things together and they look good. Just maybe Lazarus is living up to it’s vision and bringing Delphi back to life, but bigger and better than it was before!
SimpleGit is developed in Lazarus
This blog is part of a series looking at programming tools on linux and covers Lazarus 0.9.30
EDIT: Since I wrote this Lazarus v.1 has been released so I’ve updated my review here.
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.
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
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 minutes 🙂
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.
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
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
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 in this version, 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(blobs.Items[n].name); end; Memo1.Text:= sb.Text;
I’ve created my own base generic collection here and then specialised it for a custom type. All seems to work pretty well.
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 which 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
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
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
|Overall||63% – Sadly not good enough
Pictures that are worth 500 billion words!
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
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.
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?
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
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
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
For more fun with Ngrams watch this very funny video explaining this stuff
I’ve previously blogged on installing lazarus on ubuntu but unfortunately upgrading to ubuntu 11.10 broke my lazarus installation 😦 Here’s how I fixed it all.
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
and run using:
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:
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.
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
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.