Saturday 16 August 2008

Himerge (and Haskell) out to the street!

Long ago I decided to help taking Haskell a bit more outside of its own walls; I mean, it is not fair that Haskell applications and tools _only_ have to be used by Haskell programmers (this is currently the main situation) , but they should be also exposed to the outsiders, even to those with no programming experience at all!.

This point has been the main purpose of Himerge since the beginning; one of my projects that tries to throw Haskell into the world, and see how it behaves there. To get applications that you can use in a daily basis; so, daily needs can be solved and pointed out is , in my humble opinion, the only way to overcome the chicken/egg problem many new languages and paradigms have to face.

After a couple of years developing Himerge (in my spare time) , I am quite happy to see many users use it as their main graphical front-end for portage in a daily basis; and though most of the time they funnily react to the fact it is written in such a mysterious functional language; after giving it a try for a while, they realize it is not that bad, and that is actually usable! :-)

I recently wrote an article about Himerge (with some comments about Haskell) to the LinuxIdentity magazine for the special Gentoo 2008.0 edition, and which it is available in store since a couple of days ago (August 14th).

Though Himerge is quite easy and very intuitive to use, it lacks proper documentation; so this article is a first step toward collecting such a information, and at the same time, it's a way of showing to the people, that Haskell is not only fun; but it is also usable and that they need to watch it out, because it's already outside in the street :-)

Regards and Let's go for a walk!

Monday 7 July 2008

GHC 6.8.2 stable! (Himerge 0.21.9 too!)

As it reads in the topic, excellent news!

We have finally decided to get GHC 6.8.2 stable in our official Gentoo portage tree. Lennart Kolmodin filled a stabilization request yesterday to get this GHC version stable along with many of their existing libraries.

As we all know, since the Glasgow Haskell Compiler went modular, our dev-haskell/ category has increased its size considerably and the maintenance effort too; so, though we have probably got a bit late stabilizing these packages, we have carefully worked with most of them, and they have been already publicly available for anyone willing to test them from our Gentoo-Haskell overlay since many months ago.

This stabilization will greatly reduce the burden for working with Haskell packages in Gentoo now. Users don't need to keyword most of these packages versions by themselves, and a simply emerge command will suffice to get all the glory out of them :-). Therefore we expect and encourage users to test the stabilized packages and report at any bug found.

With this important stabilization, Himerge version 0.21.9 also got stabilized, which is the latest and most stable release of it. Now the process of installing this program will be smoother since all their dependencies are marked stable too and a simple 'emerge himerge' will make it.

As explained in the bug #230919, these packages are only stabilized for x86/amd64 , more arches to follow.

All the kudos go to the arch teams and everyone who has helped us to test packages and detect bugs during all this time.

Regards and Enjoy!

Thursday 1 May 2008

Himerge 0.20 release

After almost a year since the first Himerge version was released (May, 03, 2007) , the application has reached its version 0.20 as of today , introducing the following important changes for this release (from its Changelog):

1 - The queue operation 'add' is now available through a right-click from the browser version view for each package.

This will allow to move packages easier to any package queue located inside the down-right control panel.

2 - The queue operations 'remove/clear' are now available from each of the
control panel package queue through a right-click.

You only right-click on any package queue , and a popup-menu will let you choose between removing the selected package inside the queue or clear the whole queue.

With these two changes, which are ones of the most noticeable changes in the general feel&look since Himerge was released almost a year ago; it is intended to increase usability and improves the user experience around the different packages queues ; so now you don't have to move the mouse click over the whole window but instead you have the operations at hand for each package in the specific visual context.

3 - A backup of all the system files used by himerge will be created inside
the ~/.himerge/ directory.

This feature will keep those important configuration files used by Himerge saved inside ~/.himerge/. The application will read and copy these files every time you run a Himerge browser instance, so we don't miss any change.

4 - The USE flag browser is highly-improved. A new browser construction
mechanism speeds up the launch of the browser and shows a more organized and
coherent framework, listing only the necessary flags boxes available for a
given entity (a package or the whole system use flags).

In other words , now the integrated Himerge USE Flag browser will *only* show the flags boxes alphabetically ordered for the existing USE flags of a specific package. There won't exist USE flags categories with empty content.

Some code has been refactored for supporting this feature and the USE flag browser speed has greatly improved.

Himerge is an application written entirely in Haskell that it only acts like a front-end and it uses several other applications written in different languages for some operations; nevertheless , some users seem to have problems or not willing to compile many keyworded/masked Haskell packages for it and I have been creating binaries for x86/amd64 for some Himerge versions lately ; you can get the ebuilds from:

Be aware that these binaries will be usually out-of-dated and they are currently in testing stage (some runtime dependencies could be missing here and there) , so if you receive an error , please try to compile and use the source version of the package instead before reporting.

If you want to know more about Himerge , please visit its official web-site at You can also stop by where some of us who believe in graphical interfaces inside Gentoo use to idle ;-).

Himerge is a program developed by one-man , which means, one-man ideas too, but comments and bugs reports are welcome , and much more if they come with a patch ;-)


Wednesday 5 March 2008


A few days ago, after surfing through some programing languages topic on wikipedia , I suddenly found myself looking into this new object oriented programing language called Lisaac.

Lisaac is the product of the Isaac Project, currently a small but with very ambitious goals project, that goes from designing, developing and implementing a new operating system up to the design and development of a new prototype-based object oriented language in which this operating system could then be written.

I think that the computer science and software community pretty much agree that we have been kind of stuck with very old-fashioned operating system design for a while now (Do I hear Alan Kay's saying : "no innovation in the last 20 years"?) , and there have been many efforts to address most of these issues through different projects since long time, efforts that goes from very well known and old projects like the GNU/Hurd , and more recent projects like House , each of them trying to come up with the last innovation to move forward to a 'better OS world'. And this concern is really not something new , we could track it back to the 60's or 70's with the Lisp machines or with the firsts Smalltalk systems where we could for example still easily debate if it is an operating system or a programing language (or and IDE, or a collection of classes, or an alive object system, or all of that, or more than that!) , but it seems like somewhere in the road , the communities have made mistakes that avoid these kind of innovations coming upstream.

We can also look at this from another perspective , let's better blame us for being ourselves so addicted to the Unix-like model? , even those who hates this model, end up using it on a daily-forever basis, and deeper inside probably love it too.

So, what happens?

If you have read so far until this line, I might be giving the impression I have the answer for this question , and that I finally found the way of solving the new-OS projects stagnation problems .... well, no, I really don't ..... but, what I can and I am actually doing right now is to point some interest to new projects and efforts , like this one called Isaac/Lisaac.

Briefly speaking, Isaac is intended to be a fully standalone operating system designed with a prototype object oriented model , and for this, the following approach has been taken: Developing a whole new high-level compilable prototype-based object oriented language with low-level capabilities and easy C interfacing. And we get Lisaac.

Lisaac is the language with all the previously mentioned characteristics in which this new OS is being written.

This kind of Language-System design approach offers many advantages, one of them is that helps to abstract low level components very easily into a high counterpart , for example, Isaac is composed only of pure prototype objects , things like 'files' and 'processes' disappear, we deal with the operating system components as we would deal with any other object in the user level applications.

Lisaac has been modeled after 3 well-known languages mainly:
  • Smalltalk: as dynamic as possible.
  • Self: No class, only prototypes.
  • Eiffel: the language from which it inherits the most; static typing , design by contract, multiple inheritance and more.
The Lisaac's syntax resembles pretty much a mix of Eiffel and C , with a simple Smalltalk semantic ; since _everything_ is an object, all the communication between these objects go through messages sending. Even the 'if' construct is a message defined in terms of the TRUE and FALSE objects. Other interesting and handy feature is the nice interfacing with C; in Lisaac a backquoted expression like `printf("hello world\n")` is a way of making the compiler to jump into C code directly, this is a reasonable feature considering one of the main purpose of this language (writing an OS) and one of the easiest way of interfacing C code available in a so distinct language from C itself.

As a side note, both the Isaac and Lisaac projects are sponsored by several research labs and organizations and their development are intended to be very open to the software community, for example Lisaac is released under the GPLv3 (Isaac is released under a different special license though).

The latest version of the language is 0.13.1 , and though I have found some bugs here and there on this latest implementation, the development seems very active and the basic features are working very good, you can check for further information about the current status of the implementation and even download it from this page, this latest implementation has also been recently made available for Gentoo users through portage, so you can get it with a simple 'emerge lisaac' too on these systems. Other nice thing about Lisaac is its good compatibility with GCC , so you can get it working without problems (or not too much) into a GCC capable system.

The current implementation is invoked with a simple 'lisaac' command, where is a lisaac source code file, and it will generate a C file, foo.c which is automatically linked into an executable.

Though I have not tried it myself, but it seems functioning in its first stage according to the site and reports, you can already download and test an initial version of IsaacOS from here.

Well, too much talking for now, let's show some code. This is the Lisaac version of the (in)famous '99 bottles of beer!' song. :-)

Enjoy and Cheers!

// Code starts here.
Section Header

+ name := BOTTLES;
- author := "Luis Araujo";
- comment := "The cool song 99 bottles of beer!";

Section Private

+ b : STRING_CONSTANT := " bottles ";

Section Public

- main <-
+ v : INTEGER;
99.downto 1 do { i : INTEGER;
(b + "of beer on the wall, ").print;
(b + "of beer.\nTake one down and pass it around, ").print;

v := i - 1;
(v = 0).if {
"no more bottles of beer on the wall.".print;
"\n\nNo more bottles of beer on the wall, no more bottles of beer.".print;
"\nGo to the store and buy some more, 99 bottles of beer on the wall.\n".print;
} else {
(v == 1).if_true {
b := " bottle ";
(b + "of beer on the wall.\n\n").print;

Friday 7 September 2007

Himerge 0.14 released.

Himerge version 0.14 has been released.
This new version contains many improvements and bug fixes, therefore it's highly recommended updating to it.
Some of the most important changes for this version taken from the ChangeLog file are:

  • Tooltips added to the buttons's operations. You will finally know what these buttons really do ;-).
  • Support for /etc/portage/ directories. For example, now you can have package.keywords/ as a directory containing more package files.
  • Added support for calculating the direct reverse dependencies of a package. Now you can see what packages depend upon a selected package, so you can choose a more proper operation for it.
  • Now the main tree views will scroll to the cell of a specific package when this one is found using the package search feature. You now won't need to go through the whole tree view list by yourself to locate the package.
  • Now himerge will automatically move and show the notebook pages when they are initially created with an operation. So you don't have to keep scrolling and clicking on every new notebook; himerge does it for you now!.
  • Package search box improved with a drop-down list for search history. This lets you to quickly access previous packages searches.
  • Added a new accelerator to show documentation. This shows a brief help for new users.
  • The USE flag browser has been improved to match correct local use flags options for a package. Every package will show its correct set of USE flags, even if they are local ones.
  • Some bugs fixed and slight code refactoring in several functions.
With these changes, a new dependency was introduced too. Himerge now needs the gentoolkit package version 0.2.3 (or greater should also work).
Please visit the official web site at: to download this latest version (himerge-0.14) and read the installation instructions.
And of course, you always can get himerge installed from portage with the command:

# emerge -av himerge

Or using a previous version of himerge ;-)


Sunday 29 July 2007

Himerge unmasked - (GHC too!)

Today I have just unmasked the himerge-0.13 package in the official Gentoo portage tree, so you only need to accept the testing ~amd64 or ~x86 keywords for now to install himerge. I expect to get the ebuild stabilized within the next few weeks too.

himerge-0.13 depends on ghc6.6 , so you have guessed right, ghc and many other packages depending on this compiler version have recently been unmasked too in the Gentoo tree, and if you even stop by #gentoo-haskell on the irc freenode network, you will see our team is pretty happy about it :-) ; and the stabilization process has also immediately started , since most of these packages have already been well tested by many users from our Gentoo-Haskell overlay since many months now, it's a matter of a few days until we probably can have all the packages stable in the portage tree.

Feel free to report me directly any himerge bug, or/and you can also send reports about any Haskell packages in Gentoo to our team email address at haskell_at_gentoo_dot_org

Regards and Enjoy!

Thursday 3 May 2007

Himerge - version 0.13 released.

During the last few weeks i have been working on Himerge (a graphical user interface for Gentoo's portage system), fixing bugs, cleaning code, adding new features here and there. And today, i have finally released a new version of it.

Himerge version 0.13 (Alpha) is practically the first packaged version of this program, so, we could consider it as the first release, though its darcs repository have been around for several months now.

This version is still under development, and though it has been very stable for me lately, i still prefer to keep it under Alpha status.

The tarball package is available from its new web site at , from where you can also get the darcs development version if you feel like testing the latest code.

Himerge comes with many new features (most of them recently added, and many still need more testing, one of the main reason i have decided to label it Alpha yet), among them: a new resizable panel, so you can get a complete view of any operation; a web view to access the web site of a specific package; an improved use flag and package branch browser, better error handling for several operations, a different and in my opinion, more flexible layout, added some extra-operations like dependencies rebuild; and more.

Himerge also comes with a new icon set, most of them from the Tango project and a new main logo (shown here) design.

I also expect to upload an official ebuild in the portage tree soon, so keep checking.

Please, visit the himerge web site for further information.

Regards and Enjoy!

Friday 20 April 2007

Haskell for GUI Programing

Haskell has two popular graphical toolkits, Gtk2Hs and wxHaskell. I have only used Gtk2Hs, therefore, my comments come from my experience with it, but since i will speak about GUI programing in general, i guess they could perfectly apply for wxHaskell too.

Programing on Haskell offers many benefits; and i have found it gives a good combination of simplicity and robustness for the graphical user interface development model.

Simplicity: it's very easy to program graphical user interfaces on Haskell; you can get a window and a very useful widget inside it with few lines of code. Haskell as a declarative language takes to the extreme the rapid application development cycle, I'd dare to say that it perfectly can compete with the so called scripting languages in this regard.

GUI programing using gtk2hs is just a big IO monad; and though many Haskell'ers can find this 'ugly' , don't fool yourself, monadic programing and the 'do' notation offers a concise and clean way of writing easy-to-read imperative-like code, and it's when the code becomes bigger and bigger when you realize of its beauty; graphical interfaces can gradually grow very much, so i see this like an advantage and good reason for using Haskell too.

Robustness: I think we pretty much know the main difference and advantages of Haskell over other traditional programing languages here (laziness, purely functional, type inference, etc) and how all these features make a perfect combination to keep your program bug-free and easy to change/fix ; for example, it's amazing to see how you can design and develop a whole graphical user interface without mutable variables or global variables (i admit i found this a bit difficult to believe before using Haskell) ,but it's possible! , and it offers so _many_ advantages, the more significant for me has been the lack of bugs coming from these imperative features, it also helps you to reason about the layout design from other perspective, which is very interesting and benefits a more modular approach instead of an ad-hoc design where you just keep updating bunch of global data structures in-place through signals and events.

Other definitive characteristic that makes robustness possible is the static typing and type system. Haskell helps you to reason about 'types' all the way down along your code, and that's not less true for GUI programming. Many dynamic and weakly typed languages have tried to show to the programming community they are the best way of getting GUI stuff done right and they usually strength the fact of rapid development cycles in opposition to lower-level approaches; really, i can understand this position a bit, most of the first GUI systems came from these kind of languages, nevertheless, i think most of them are in disadvantage with Haskell due to the type system.

Types help both to the machine and to our human brain to think in terms of a common abstraction as an interface for an universe of different values. We can reason 'in harmony' with our computer in an easier way through these abstractions than with a dynamic, typeless language. This kind of reasoning, evidently, will help to the programmer to get more robust programs (and i think i don't need to explain here why that's important for GUIs) and at the same time i have realized this reasoning fits well into the different GUI components representations too; what i am saying here, is that types are practically (and conceptually) a better representation than the objects offered by most of the object-oriented programing languages to work and manipulate graphical elements, and i highly think this is going to contribute to the popularity of Haskell in the future, as a possible replacement or improvement for many aspects of the OOP approach.

And if those aren't enough reasons to use Haskell for GUIs; here is the third one: it's fun.

Since Haskell gives you so many features to make simplicity and robustness of code a reality without too much effort, you pretty much can enjoy coding without worrying about low-level details or possibles unwanted side-effects behaviours, what else could you ask for? :-)

Ok, too much keyboarding for now ... if you still aren't convinced, there is only one way of knowing for sure, just give it a try!


Wednesday 18 April 2007

Himerge updated

Today I have released new code (bringing new features and bugs fixes) for himerge; though the development has been very slow (and stopped) lately because I have been busy with other stuff, I have always took some of my free time to work around himerge during the last months. The main difference between this code and the previous version is that this one starts supporting ghc6.6 and the new gtk2hs API.

These are also some of the other major changes introduced on the code:
  • Added a new tool-bar layout.
  • Use flag browser improved.
  • Package branch browser improved.
  • Removed the 'clean' option.
  • Added mozilla support into the main 'Package Information' view to show the eix search result on html/css. So we can directly visit the listed homepage of the package, among other possible things, like for example, to visit html documentation about himerge (not yet implemented) straight from this view.
  • Fixed some bugs on the main tree-views.
  • From a developer point of view (not visible to the user): added type signature to most of the functions, fixed some warnings, and part of the code re-written for easier reading.
  • And many more!
Since there were so many changes ; I decided to start another darcs repository from scratch and change its name to himerge-darcs/ , to clearly state this is the darcs version of the package; since i hope to start releasing tarball packages versions soon.

Download this newcode using:
darcs get --partial

There also exist a snapshot of the previous darcs version on himerge-009 (this version compatible with ghc6.4 and gkt2hs 0.9.10); it is highly recommended to stop using this version though.

You can check out the himerge temporary web-site at my projects site ; please, read those instructions on the site and the readme.txt file before using himerge. I also updated its ebuild on the Gentoo Haskell overlay, try it out with 'emerge himerge-darcs'.

This isn't yet a final release ; therefore I encourage everybody to play with caution and report any bug ; mainly if it will come with patches :-)