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!

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 bugs.gentoo.org 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!

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: http://dev.gentoo.org/~araujo/stuff/ebuilds/.

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 http://www.haskell.org/himerge. You can also stop by #gentoo-guis@irc.freenode.net 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 ;-)

Regards,

Lisaac

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 foo.li' command, where foo.li 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;
                        i.print;
                        (b + "of beer on the wall, ").print;
                        i.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.print;
                                (v == 1).if_true {
                                        b := " bottle ";
                                };
                                (b + "of beer on the wall.\n\n").print;
                        };
                };
        );