Saturday, February 28, 2009

Paladin can Bootstrap Itself Now

Up until now, it's been possible to build Paladin using Paladin, which isn't that big of a deal -- the project manager part of the IDE is very much a simple build. PalEdit, however, is not. Only now is it possible to build it with Paladin.

The primary reason for the complexity with PalEdit are rez files. For those unfamiliar with it, rez is the name of a resource compiler for Macintosh. Maarten Hekkelman, the programmer behind Sum-It and Pe, wrote a version for BeOS which uses text-based resource files for menus, dialog windows, key bindings, and more. Sum-It and Pe -- and by inheritance, PalEdit -- use these files extensively, so until now, jam has been a requirement to build Paladin's text editor. While this is not a shot at jam, for someone who much prefers an IDE to a text editor and a terminal, this is a pain.

It's not all perfect, though. This is the development branch, after all. There are issues in building Sum-It, but this might be because of the speed with which I put the project for building it together. Then again, putting together a project with Paladin should be quick and relatively painless. Either way, the rez resource compiler isn't all that helpful in handling errors in its files. In the process, though, I patched some more bugs in the stable branch. Progress is good. :)

Sunday, February 22, 2009

The Road Ahead for Paladin

For some strange reason, February is one of two months of the year -- December being the other -- where Real Life gets a stranglehold on my free time. Music teachers in the U.S. typically put on at least one Christmas-related program each school year, so December isn't at all a surprise, but February... that one is still a mystery to me. Between the icky weather, my daughter's birthday, and replacing a vehicle, I haven't had much spare time. Most of the spare time I have had has been spent tinkering with Linux because I've been too tired to do much of anything else until yesterday and today.

Even now I'm pretty surprised by the number of bugs that have been squished since Paladin's first beta release. There will be at least one more release candidate before the final 1.0. There probably wouldn't have been quite so many were it not for so few people actually reporting bugs. The vast majority of bugs fixed have been ones I've noticed.

None of this is to say that Paladin is more or less standing still, feature-wise. The bugs from the release candidates were almost all ones which I discovered while working on the development branch. Some of the new features include support for shell scripts and rez files, lots of internal cleanups, shorter build times, and the ability to recursively add a folder's contents just by dragging and dropping.

Adding entire folders makes migrating from other build systems incredibly simple and fast, especially when groups are also created for the user. Projects which have lots of files and subfolders, like Open Sum-It, for example, all that is needed is to drop the main sources folder onto the project window, add a few include paths, and change the system libraries in the Project Settings window. It won't be much longer and Paladin will be used to build PalEdit instead of jam -- rez support is still under heavy development as of this writing.

I don't know how far I'll be taking Paladin development, really. The future is wide open in that respect, but I'll describe some of the features that I'd like to make happen most. If nothing else, it'll make for some good Sunday evening light reading. ;-)

One feature that will be added, barring unforseen issues, is a one-click backup of a project into an archive. Coupled with a command-line switch, it could make for some simple nightly snapshot files and also provide a good alternative to using revision control for those people who don't have access to CVS, SVN, or whatever.

A personal code library could also be really handy, and it's a feature that I really want to see happen. The idea is that sitting around my hard drive are some reusable classes that I've used in different applications. For me, this includes a C++ wrapper class around SQLite3, a TextFile class that allows reading of a file one line at a time, and a bunch of things that eventually made their way into LibWalter. There aren't really so many classes to warrant my own personal library -- libdw or whatever -- but there are enough of them to be difficult to manage manually, particularly if I find a bug in a frequently-used class. The solution? A personal code library without the overhead inherent with a full-blown revision control system. Not all of the details have been sorted out, but if I think it would help me personally, others probably would, too.

Code generation facilities could also speed things up in a useful way, too. BeOS C++ developers do a lot of subclassing, and it would be nice to have a way to quickly give a class a name, check a few boxes, and have the generator churn out skeleton code. Instead of using cut 'n' paste or manually typing out a MessageReceived function for a BWindow subclass, checking a box could make the genenerator spit out something like this:
 void
MyWindow::MessageReceived(BMessage *msg)
{
switch (msg->what) {
default: {
BWindow::MessageReceived(msg);
break;
}
}
}

One checkbox to get this? Sounds like a nice tool to do all the boilerplate code, if you asked me.

Basic makefile and/or jamfile generation is still on my to-do list and would make migrating to a more complex build system easier. Code completion would be a wonderful help -- I'm forever having to look up the parameters to a BListView constructor because I use them enough to want to have them memorized, but not often enough that I actually have memorized them. A preferences window and profiling support are coming, too.

All in all, there are lots of exciting things coming. I'm not crazy enough to think that it'll become the de facto IDE for Haiku developers, but if it helps a few people start developing for BeOS / Zeta / Haiku and helps grow the community a little, that'll be far more than I ever thought would happen.

Sunday, February 8, 2009

Another Paladin Release Hits Light of Day

This one sure took quite a while. Murphy seemed to be in full swing during its development -- there were quite a few instances where there just wasn't enough time. Writing the documentation took quite a while, and then my development box didn't want to work properly. Just as mysteriously, everything started working right again just this afternoon. In the process, my development machine has ended up multibooting XP Pro, Ubuntu, Zeta, R5, and Haiku. I'll certainly be able to test for compatibility, that's for sure!

This release for the stable branch really isn't anything overly exciting except for bugfixes and (finally) some documentation, but that's not entirely a bad thing. It seems like unlike most of my other projects, Paladin has had general stability issues -- almost like there are always these little niggling details which just keep cropping up. Each time something comes up, though, I'm not generally too long in squishing them.

As I am able, I'm also working on the development branch. Right now, I'd say that there are two features that I will be implementing unless there are major issues: support for adding files and groups just by dropping a folder onto the project window and build support for rez files so that I can get rid of the jam system for PalEdit.