Hello. And welcome to the History of GNOME. Episode 1C applications. First of all, I'd like to apologize for the lateness of this episode. As you may know if you follow me on social media, I've started a new job as GTK Core Developer for the Grum Foundation. Yes, I'm actually working at my dream job, thank you very much.
Sadly, this has changed some of the things around my daily schedule. And since I can only record the podcast when ambient noise around my house is not that terrible, something had got to give. And this time, it was this podcast. Again, I apologize and hopefully it won't ever happen again. So, let's go back to the history of GNOME.
Over the course of the first chapter of the main narrative of the history of the GNOME project, we have been focusing on the desktop and core development platform produced by GNOME developers. But we did not really spend much time on the applications. except when they were part of the more commercial side of things like Evolution and Nautilus. Looking back at Miguel's announcement though, we can see a complete set of user-friendly applications.
in the list of things that the GNOME project would be focusing on. What good a software development platform and environment are if you can't use them to create and run applications? While GIMP and GNOME share a great many things, it's hard to make the case for the image manipulation program to be part of GNOME. Yes, it's hosted on GNOME infrastructure, and yes, many developers contributed to both projects.
Nevertheless, GIMP remains fairly independent and while it consumes the GNOME platform it tends to do so in its own way and under its own direction. There's another issue to be considered when it comes to GNOME applications, especially at the very beginning of the project. GNOME was not and is not a monolithic entity.
There is no such thing as GNOME developers, unless you mean people writing code under the GNOME umbrella. Anyone can come along, write an application, and call it a GNOME application, assuming you use a copyleft license. GTK for the user interface, and a few other GNOME platform libraries for integrating with things like settings. At the time, code hosting and issue trackers weren't really a commodity like nowadays.
Even SourceForge, which is usually thought to have always been available, would become public in 1999, two years after GNOME started. GNOME providing CVS for hosting your code, infrastructure to upload and mirror release archives, and a bug tracker was a large value proposition for application developers that were already... philosophically and technologically aligned with the project. Additionally, if you wanted to write an application, there was a strong chance that you had contributed
or you are at least willing to contribute to the platform itself, given its relative infancy. As we've seen in episode 1.4, having commit access to the source code repository meant also having access to all the Canon modules. The intent was clear. If you're writing code good enough for your application, then it ought to be shared across the platform, and you should drive its inclusion in the platform.
As we've seen all the way back in episode 1.1, GNOME started off with a few core applications, typically utilities for the common use of a workstation desktop. In 1.0 release, we had the GNOME user interface, around Miguel de Casa Midnight Commander file manager, the Electric Eyes image viewer, courtesy of Karsten Heitzler, a set of small utilities in the GNUM Utils scrap bag, and three... text editors. GXEdit, GEdit and GNOTEPAD+.
I guess this decision to ship all of them was made in case a GNOME user ended up on a desert island, and once saved by a passing ship after 10 years, they could be able to say, this is the text editor I use daily. This is the text editor I use in the holidays, and that's the text editor I will never use. Alongside this veritable text editing bonanza, you could also find a small personal information management suite.
with GNOME Cal, a calendar application, and GNOME Card, a context application, and a spreadsheet called GNUMERIC. The calendar application was written by Federico Mena in 1998 on a dare from Miguel in about 10 days, and it attempted to replicate the offerings of commercial Unix operating systems like Solaris. The Contacts application was written by Arturo Espinosa pretty much at the same time. GNUM Cal and GNUM Card could read and export the standard vCal and vCard formats, respectively.
and that allowed integration with existing software on other platforms as an attempt to lure away users from those platforms and towards GNOME. Gnumeric was the brainchild of Miguel and the first real attempt at pushing the software platform forward. The original GNOME Canvas implementation, based on TK Canvas, was modified not only to improve the performance and bindability,
but also to allow writing custom canvas elements in order to have things like graphs and charts. The design of Gnumeric was mostly mutuated from Excel, but right from the start... The idea was to ensure that the end result would surpass Excel and its limitations, which was a somewhat tall order for an application developed by volunteers. It clearly demonstrates the will not to just copy commercial products, but to improve on them and deliver a better experience to users.
Gnumeric additionally came with a plugin infrastructure that exposed the whole workbook, sheet and cells to each plugin. Both the PIM application and the spreadsheet application integrated with the object model eFERN. and provided components to let other applications embed or manipulate their contents and data. While Gnumeric is still active today, 20 years and three major versions later,
both Gnome Cal and Gnome Card were subsumed into what would become one of the centerpieces of Simeon, Evolution. Gnome 1.2 remained pretty much similar to the 1.0 release. from an application perspective. The various text editors were moved out of the release and went along with their own pace, with G-Edit being the main survivor. Electric Eyes fell into this repair
and was replaced by the Eye of GNOME as an image viewer. The newly introduced ggv, a GTK-based GUI layer around GoScript, was the PostScript document viewer. Finally, for application developers, a tool called Glade was introduced as a companion to every programmer's favorite text editor. Glade allowed creating a user interface using drag and drop from a palette of components.
Once you are done with it, it would generate the C code for you, alongside the needed autotools gunk to build it, if it couldn't find any. The generated code was limited to specific files, so as long as you didn't have the unfortunate idea of hand-editing your user interface, you could change it through Glade, generate the code, and then hook your own application logic into it.
rinse and repeat. Many projects of that era started off with generated code from Glade and if you're especially lucky you will never have to deal with it. Unless, of course, you're trying to write something like the history of the GNOME project. For GNOME 1.4, we only see Nautilus as the big change in the release in terms of applications.
Even with an effort to ensure that applications as well as libraries exposed components for other applications through use, most of the development effort was spent into laying down the groundwork of the desktop itself.
applications came and went but were leaf nodes in the graph of dependencies and as such required less coordination in their development and fewer formalities when it came to releasing them to the users It would be a long time before somebody actually sat down and decided what kind of applications ought to be part of the GNOME release.
With this episode, we have now reached the end of the first chapter of the history of the GNOME project. The second chapter, as I said a few weeks ago, will start on January the 17th. And for the next four weeks I'm going to be busy with the end of the year holidays here in London. Once we're back, we're going to have a little bit of a retrospective on the first chapter of the history of GNOME before plunging directly into the efforts to release GNOME 2.0 and what those entailed. So...
See you next year for Chapter 2 of The History of Gnome.