DarkWyrm's Haiku Site

Lesson 22: A First (Bigger) Project

2011-12-28T11:54:00.000-05:00

After a long hiatus, here is the next lesson in the series. Lesson 22 begins a project which will delve deeper into what is involved in developing larger projects in Haiku. In this case, we begin working on a text editor, QuickEdit.

Programming with Haiku, Lesson 22
Lesson 22 Source Code

What's in a Name

2011-10-05T07:28:00.000-04:00

In case you haven't heard, Mozilla spawned a new project -- a 3d gaming engine for browsers. The name? Gladius. It's part of a general platform called Paladin. Yes, you heard that right. Paladin. I've even contacted the main developer, Alan Kligman. I haven't heard back from him about the name conflict, but I'm less than pleased. Especially in light of this thread on their Google Groups list. Gee, thanks, guys. I *really* don't want to have to rename my 3-year-old IDE because some people over at Mozilla chose the same name. Stay tuned.

Hot & Cold... Meh

2011-09-17T16:00:00.000-04:00

Yeesh. A month since my last post here. It would seem that sometimes I run hot and cold in my Haiku hacking efforts and right now I seem to have hit a cold spell. I'm just having a hard time conjuring up the motivation to write code, lessons, or much of anything else at the moment. I've started up my own PC repair business on the side from school, so some of my "free" time is being spent working on it. I'm not going anywhere, but apparently I need a little time off. I'm not going anywhere, but things might be quiet for a little while. You know where to find me in the mean time. Have a great one everyone. :-)

Time Flies...

2011-08-17T07:47:00.000-04:00

Even when you're not having fun, it seems. I haven't been doing anything out of the ordinary and, lo and behold, it's the first day of school for me. Time seems to have gotten away from me on this one -- I haven't been able to get done anything I planned to a couple of weeks ago. It'll probably take a little time to recover from the madness that is the schedule during the first couple of weeks of school, but I haven't given up. I've got a lesson that is almost complete and ready to publish and another started. Paladin is making good headway but I apparently won't get a release out before summer's end. Ah well. C'est la vie. Until next time, everyone.

News Stew

2011-08-01T16:32:00.000-04:00

From the looks of this blog the last few weeks, you'd think that I'd dropped off the face of the earth, but you'd be wrong. I've just been too busy to post. I took a week off for vacation, but I've also been coding quite a bit. I planned on doing a lot more while on vacation -- coding is fun for me -- but I ran into some problems which shot most of the time I could've spent writing code. Anyway, I'm in the process of retooling the code responsible for using project templates in order to make them more flexible. I've also been working on a couple of lessons. One finishes out the Translation Kit, but it's taking a *lot* longer than most lessons would because I'm in the process of learning the basics of writing a Translator and a support framework for writing them. Writing a Translator isn't hard, but it is unfamiliar for me.

Paladin's next release is now on the horizon. The new work on the template section will make more complicated possible, including one which is *this* *close* to being usable: a Tracker Addon template which should make writing them dramatically easier. There are some new command-line utilities which I've written that should come in handy. luare (lu-AR-ay), does regular expression search-and-replace without the mess that is sed. luagrep searches for text in a file, but only one file -- it's mostly meant to be used in combination with find. A text-based build system, pbuild, should make into the release. I've wanted to use a text-based build system for Paladin development, but I wasn't satisfied by any of them out there: make is weird and aggravating, scons is slow, jam has zero documentation, and many are just overkill. pbuild leverages full-blown Lua in a way that you don't have to write much to do basic tasks, but more complicated stuff is possible.

New to Paladin is a Find command which searches all project files and it works quite nicely. It'll be possible to search using regular expressions, but it will be using Lua's regular expressions. Lua doesn't do regular expressions quite the same as Perl or *NIX, but it's pretty close -- most of the differences are just few obscure uses. The boost in speed and simplicity are worth the change.

I haven't stopped writing, just slowed down because the work isn't as easy or fast as I'd like and I'm also trying to get most of the Paladin work for the release done before I have to go back to school. Have a great one, everybody!

Programming with Haiku, Lesson 21: Replicants

2011-07-05T20:47:00.000-04:00

Here is a topic that for the longest time as a BeOS/Haiku developer, I had no idea how to do and didn't really feel enthused on the concept of learning. Of course, now all the major platforms have desktop gadgets. Ironically, writing a replicant is really easy if you already know how to write basic Haiku GUI applications already. Find out how in this lesson.

Programming with Haiku, Lesson 21

COOOder Craziness in Ubuntu

2011-07-05T09:01:00.000-04:00

Here's a quick tip for all of you who use the package openoffice.org-coooder in Ubuntu: don't install from Synaptic. It won't work unless you know some advanced dpkg kung-fu that I don't. Instead, go to your friendly neighborhood Ubuntu mirror and download the .deb manually. Double-click on it to install it and everything will work just fine. Here's a download link for your convenience: COOOder at the US Ubuntu mirror. Have a great day everyone!

Haiku, Meet Lua. Lua, Haiku

2011-06-14T12:23:00.000-04:00

I've been pretty quiet since I got out of school last week. It's not because I've been too busy to do anything. Quite the contrary. I've had my head down in the trenches, hacking away. About six months ago, I posted a screenshot of CHaikuRun, a test application which interacted with the Haiku API from the C language. I have a new one:

On the outside, not all that different from the other one. Under the hood, though, the two test apps are worlds apart. Here is the source code:


function LuaAppSetupFunction()
    local win = MakeObject("PWindow");
    win.SetProperty("Frame", PRect(100,100,500,400))
    win.SetProperty("Flags", BQuitOnWindowClose)
    win.SetProperty("Title", "LuaGUI")

    local view = MakeObject("PView")
    view.SetProperty("Frame", PRect(0,0,400,300))
    view.SetProperty("BackColor", PColor(224,224,224));
    win.RunMethod("AddChild", {view.id})
    
    local label = MakeObject("PLabel");
    label.SetProperty("Frame", PRect(10, 10, 350, 60))
    label.SetProperty("Text", "Haiku, meet Lua!");
    view.RunMethod("AddChild", {label.id})
end

RunApp("application/x-vnd.dw-LuaGUI", "LuaAppSetupFunction");

That's pretty darn short, if you ask me. A graphical HelloWorld app can be written in 6 lines of code:

 function LuaAppSetupFunction()
    local win = MakeObject("PWindow");
    win.SetProperty("Flags", BQuitOnWindowClose)
    win.SetProperty("Title", "Hello Haiku!")
end

RunApp("application/x-vnd.dw-LuaGUI", "LuaAppSetupFunction");

And I thought writing in C++ was easy. Yeesh. That beats everything I've seen under Haiku/BeOS except yab and quite competitive to something like wxPython. Then again, I could argue that this is a lot clearer than yab, but I digress.

The code snippets I've posted above are why I manually wrote Lua bindings instead of using SWIG. I'm not sure that I could have gotten SWIG to generate them in a way which has at least the same ease-of-use as the C++ API. I've still got a *lot* more testing to do and some more objects to implement before I can do a release, but this is definitely some progress and some good news, too. It's officially a good day now. :)

Libcharlemagne and Paladin

2011-06-02T00:17:00.000-04:00

Just a quick post before I head off to bed. :) While school has been as busy as typical this year, last week and this week (mostly this) have been spent with many moments coding. The results? Project-wide find and replace -- a long-needed feature -- and major progress on libcharlemagne. Most of this library work has actually been spent on writing Lua bindings for libcharlemagne. It's not there yet, but it's getting there.

Originally I was going to use SWIG to do it, but it's hard to have a nice API in a language using a generic wrapper. Some language features just don't wrap very well. On the up side, I found out just how flat-out easy it is to call C from Lua. It's almost scary how easy it is. Current code in writing is to turn tables into libcharlemagne's generic data container and vice versa. Hopefully it won't be *too* long before I can post the source for a Lua script that uses the GUI and make a testing release. TTFN

Programming with Haiku, Lesson 20: Drag and Drop

2011-05-17T07:38:00.000-04:00

In this lesson we seek to understand the part of the Interface Kit which lets us move things around in Tracker using the mouse. We will examine both ways of transferring information from one program to another, both the simple way and the more flexible (and complicated) method.

Programming with Haiku, Lesson 20

Ubuntu Natty Narwhal: Epic Fail

2011-04-28T20:21:00.000-04:00

I saw it coming, and now I can safely say "I told you so" and so can a lot of other people who were expecting the new Ubuntu release to be unstable. 11.04 was released today to much hoopla from many news sites. Never have I been more disappointed by the stability of a release. Ever. Even Karmic Koala -- with which I had a terrible experience -- wasn't as horrific. I'm not even talking about the speed of the repository servers, which have been bombarded and are, thus slow. It would seem that at least on some machines, system stability rests on the edge of a knife. One of my machines would number among that lot.

I have a secondary machine at home which my children usually use to play games on Windows 7. It also runs the Linux distro flavor-of-the-week. During my vacation time this week I've toyed with Kubuntu 10.10, which was unacceptably slow, and Xubuntu 10.10, which had some notable issues. I was underwhelmed by both.

What has been my experience so far? Not good, I'm afraid. I grabbed a copy of Natty this morning, burned it, and started a clean install. The installer has a few minor annnoyances which have been introduced, such as not being able to type in the mount point for a specified partition. Irritating, but I can live with it. It also allows you to skip downloading certain parts. Seeing that the download speeds weren't as good as I liked, I hit the skip button to pass on downloading updates. My clicking was met with a hung installer. Luckily, I had passed the point where I could reboot without hosing the install, so I hard rebooted the thing, which at this point was my only option.

The first official boot didn't go any better. The GRUB screen was distorted, which didn't bode well. Once Ubuntu started booting, the terminal display was an utter mess and completely unreadable. X started and I was informed that I would have to use the classic desktop. The message was completely expected, but it was accompanied by portions of the screen which needed redrawn -- this would be disturbing to a newbie. Next stop: getting the proprietary Nvidia drivers. Ho-hum. They installed without a hitch (surprisingly), but after rebooting into the new shiny Unity environment I was met with yet another surprise: a totally unresponsive desktop. The only thing that it would do is let me move the pointer. The only session option I had which actually works is the Classic desktop with effects disabled. This is actually a step backward considering that it worked very well under Maverick.

I've heard quite a few good things about 11.04, so it can't all be as terrible as my experience has been. I'm sure in the next couple of weeks a lot of things will shake out. Personally speaking, Natty Narwhal should have been a little less ambitious because this release will not reflect well on Ubuntu as a community or on Canonical. Perhaps Oneiric will be better. It certainly can't do much worse.

Lesson 19: Deeper in Application Scripting

2011-04-12T20:32:00.000-04:00

When we last looked at application scripting in Haiku, we merely scratched the surface. Using the hey command and the basic concepts behind the Haiku scripting model, we were able manipulate running applications to do our bidding. Now we will delve into the C++ code which can do the same thing with much greater flexibility and even implement scripting support in our own GUI controls.

Programming with Haiku, Lesson 19

More Code and Another Lesson Soon

2011-04-11T20:03:00.000-04:00

Yeesh. Almost a month since the last post, but I'm still scratching my head trying to figure out where it went. Workload at school went through the roof until last week, so I think that's what happened. Life will hopefully return to some semblance of abnormal. Lesson 19 is almost ready for publication -- look for it hopefully later this week.

I've also been writing some code, too, when I've had a moment. Paladin received a few fixes and tweaks. For example, adding a file to a repository from within the project window also adds its partner file. Same goes for removing it. The Lua scripts that I've written to automatically generate the code for different objects in libcharlemagne received some significant refactoring and the spec files used to create them are simpler now, too. All of the GUI control objects which were complete before are now generated, fixing at least a couple bugs that I discovered while writing the spec files, probably along with some others that I didn't know about. I'm in the process of implementing a couple of objects which were just skeleton files before. More progress is good. :-)

Programming Lesson 18: Application Scripting

2011-03-15T20:27:00.000-04:00

After a _long_ hiatus, Lesson #18 is available for your reading pleasure. The topic? Scripting Haiku applications, possibly one of the least understood aspects of the operating system. Learn about hey command, its uses, and even see some of the most English-like bash commands ever. Also see how to make almost any Haiku application answer your beck and call and tinker around the operating system with an updated version of the ScriptWorld demo application, Scripting Explorer.

Programming with Haiku, Lesson 18
Supplemental Source Code: Scripting Explorer

A New Hat... Actually It's a Fedora

2011-03-12T23:15:00.000-05:00

I've had fundamental issues with the last few of Ubuntu releases that I've seen come out of Canonical. Jumping from Jaunty to Karmic was foolish -- not all of the bugs had settled out of it for at least a month after its release. Lucid moved the default location of the window buttons -- it is unwise to muck around with a geek's muscle memory. Maverick doesn't seem quite as stable overall, although I've run into fewer problems with jumping from Lucid than Karmic gave me. It is also completely nonsensical and wrongheaded to change introduce a mode to the Close button for Rhythmbox -- it effectively minimizes to the tray if the close button is pressed while it's playing, but closes the program if it isn't. Stupid, stupid, STUPID.

I've been looking for a new distro as a result. Judging from the GNOME vs Canonical news of late, I must not be entirely without justification to be less than satisfied. I've tried Unity. Didn't like it. I've really wanted to go with a Debian based system, if at all possible, because I know the basics of apt well and I like its speed. I wasn't enthused by OpenSUSE's dog-slow first impressions. I've also experimented with CentOS, but I like something a little more up-to-date, so I'm giving Fedora 14 a go. The last time I did anything significant with it was 11(!) versions ago. Still learning, but so far, the experience has been pretty pleasant. I've always liked Red Hat as a company even if I wasn't necessarily wild about RHEL or Fedora. I may be changing my mind about that one. We'll see. Here's to hoping. :-)

Automatic for the People

2011-03-06T20:17:00.000-05:00

It's amazing how sometimes an idea hits me. It dawned on me this past week that much of the work I've been doing on libcharlemagne is grunt work. The code file for the PTextView text editing object is literally like 1000 lines long, far longer than most files that I write, and a large portion is stuff that is repeated with very little variation. In a matter of a few nights and a massive codefest yesterday, I've got the majority of a Lua code generation script which will automate most of the work for the different GUI controls. This is a good thing -- already I've found more than a couple bugs in a couple files just while reviewing them for work with the script. All that's left is the code for generating an object's methods -- tricky, but it should be doable with some thought. The more I work with Lua, the more I wonder what other tasks it might be useful for. Who knows? Perhaps PDesigner might end up as a visual designer with the ability to embed Lua code or something. Interesting thoughts for a pleasant Sunday night after a relaxing day. :)

More Progress on Code Lookup

2011-02-22T17:18:00.000-05:00

I finally came upon a term for the new Paladin feature that I've been doing R&D on the last couple of weeks: Code Lookup, which will look up code definitions for enumerated types, methods, and more using a database from header files. I'm getting better at hacking Lua, though I would still call myself a novice. I rewrote the parser using a more structured, less hackish approach, and I've managed to make it work pretty well. Considering that I've never delved into this particular realm of computer science before, I'd say that I did OK. It sits on top of the luasql engine at the moment, which needs some more work. Once I've gotten it working properly under Ubuntu, I'll be migrating the project to Haiku. From there, integrating Code Lookup into PalEdit shouldn't be too difficult. I'm not wild about adding more dependencies, but I can easily see greater use of Lua with the Paladin suite because of its flexibility and ease of integration with C/C++. I can't wait until this gets to the point where I can use it under Haiku.

Libcharlemagne, Lua, and Haiku

2011-02-17T20:26:00.000-05:00

The last couple of weekends I've taken a little time away from writing lessons to find some much-needed refreshment in coding. The target? Lua, oddly enough. I twiddled with it for a while and discovered that as scripting languages go, I have to jump through fewer hoops to get something quick-and-dirty done with Lua than others and the code isn't write-only like Perl.

The first project was a doozy: write a C++ header parser and (later on) dump the parsed C++ information into a SQLite3 database so that I have the hard stuff done for implementing something code completion for Paladin. Code completion has been #1 on my hit list of features for a long time now, but I haven't had a clue where to start to implement it, and ctags sure didn't seem to be a step in the right direction. I've learned enough about Lua to really like it and want to eventually put together an elegant implementation of the Haiku API via libcharlemagne. I haven't gotten to more advanced topics like metatables and such, but I'm pretty sure that the rest will come in time. Once I finish cleaning up PalEdit's internals like I was working on last summer, I can easily see embedding Lua scripting into it for more powerful editing features and plugins.

Lesson 17: Writing a New Control, Part I

2011-01-31T15:36:00.000-05:00

Yet another three weeks has gone by and I didn't even notice. Yeesh. Time flies when you're coding, so no big deal. *shrug*

This lesson is one of several which delves into the art of control writing for Haiku -- not just a quick-and-dirty hack on an existing one, but writing a new control which rivals existing ones in quality and features. Learn how controls handle drawing themselves and write a basic color display control.

Programming with Haiku, Lesson 17

C, Meet the Haiku GUI

2011-01-27T22:42:00.003-05:00

It's official: after a couple of hours of furious code, I have written a graphical Haiku application from C, courtesy of libcharlemagne. No, not C++ and there is none of that fancy application scripting via BMessage and hey, either. The title? CHaikuRun, of course.

With mappings from C++ to C being pretty ugly, the code won't exactly win elegance contests. Also, there may be some C-to-HTML ickiness here, so bear that in mind.

#include "libcharlemagne.h"
#include <stdio.h>

int32_t InitApp(void *pobject, PArgList *foo_in, PArgList *foo_out)
{
    /*    This accomplishes the same kinds of tasks as what would
        normally be done in a BApplication's child class constructor */
    
    void *mainwin = pobject_create("PWindow");
    pdata_set_bool_property(mainwin, "Visible", 0);
    pdata_set_string_property(mainwin, "Title", "CHaikuRun");
    pdata_set_rect_property(mainwin, "Frame", 100, 100, 500, 400);
    pdata_set_bool_property(mainwin, "Visible", 1);
    pdata_set_int_property(mainwin, "Flags", 0x00180000);
    
    /* Here is an example of how to run a method for an object in C*/
    void *backview = pobject_create("PView");
    pdata_set_rect_property(backview, "Frame", 0, 0, 400, 300);
    pdata_set_color_property(backview, "BackColor", 224, 224, 224, 255);
    
    /* These have to exist for running a method, but they can be reused */
    PArgList *in = create_parglist();
    PArgList *out = create_parglist();
    
    /* AddChild requires the object ID of the child view to add */
    add_parg_int64(in, "id", pobject_get_id(backview));
    pobject_run_method(mainwin, "AddChild", in, out);
    
    void *label = pobject_create("PLabel");
    pdata_set_rect_property(label, "Frame", 10, 10, 350, 60);
    pdata_set_string_property(label, "Text", "Hello Haiku from the C language!");
    
    empty_parglist(in);
    add_parg_int64(in, "id", pobject_get_id(label));
    pobject_run_method(backview, "AddChild", in, out);
    
    
    /* Free allocated heap memory */
    destroy_parglist(in);
    destroy_parglist(out);
    
    return B_OK;
}


int
main(void)
{
    /* Start up the object system. Without this, we can't do anything with libcharlemagne */
    pobjectspace_init();
    
    void *papp = pobject_create("PApplication");
    run_app(papp, "application/x-vnd.dw-CHaikuRun", InitApp);
    
    /* Not absolutely necessary here, but it frees all objects allocated by the broker */
    pobjectspace_shutdown();
    
    return 0;
}

Closer to Scripting Language Support

2011-01-26T06:28:00.000-05:00

In the few weeks since my last post I've been working more on bringing the ability to write graphical Haiku applications to languages outside of C++. PDesigner has seen some refactoring, and now it's a lot lighter -- all of the object system code upon which PDesigner has been built was spun out into its own library, libcharlemagne. I'm working with SWIG in order to be able to generate the necessary bindings for the supported languages.

I've run into a small snag, however: I don't know very much about other languages except for a passing familiarity with Python, and certainly not enough about it to know what I'm doing. Just last night I checked in some code to the repository which, in theory, should make it possible to write a Haiku app from Python, Lua, or just about any other scripting language supported by SWIG. There's also a C interface for those people who want to use it. Documentation will be coming soon.

Once I get it to the point where other people will want to use it, it will be available both with the Paladin suite and as a separate download. If you have a little time to tinker and know something about using SWIG for your favorite non-C++ language, get in touch with me.

Lesson 16: Fonts

2011-01-09T08:44:00.001-05:00

Most people think of fonts as merely a means to an end, but in this lesson we will take a crash course in typography and the very basics of displaying text in Haiku. Also included is a review of the second unit, lessons 6 through 15.

Programming With Haiku , Unit 2 Review
Programming With Haiku, Lesson 16

New Year, Same Old Stuff

2011-01-03T08:12:00.000-05:00

In about 15 minutes, I'll be heading off to work. The two weeks vacation that I had for Christmas went really fast. This would probably be the first vacation I've had in a long time that I've felt like I didn't get much done.

The big project I spent time working on was PDesigner's object interface. Just a couple of days ago I managed to implement the rest of the code which makes it possible to incrementally learn the interface for any object -- what each object's methods, properties, and events it has and what each method's arguments are and any values it returns. I guess now it's just a matter of adding more of the Haiku API to it and moving the code out of PDesigner and into a shared library when it's ready for release.

The other project I spent time on was more of my Programming with Haiku series. I've hit a bit of a slow spot in the series because I'm not as familiar with the material that the lessons are covering at the moment. Barring major issues, another lesson should be seeing light of day later this week. Have a happy New Year, everyone!

Lesson 15: Making a New File Type

2010-12-12T12:51:00.000-05:00

Depending on what kind of projects you write, you may have to create a new file type from time to time, such as a document type for the next Word-killing word processor. While not difficult, making one needs a bit of knowledge from different places in the OS and the API. In our final lesson which focuses on the Storage Kit, we will learn about MIME types, how to show the OS how to automatically identify files of your new type, and more.

Programming with Haiku, Lesson 15

Coding Progress

2010-11-29T22:02:00.000-05:00

With as crazy busy as my teaching schedule is keeping me this year, it's challenging to find coding time on the weekends and nearly impossible during the week, but with Thanksgiving Break giving me a 5-day weekend, I managed to get another lesson posted and do some serious hacking. The target this time? PDesigner. It hasn't received much attention in quite a while, but it has been a learning experience from its infancy. It's yet another visual GUI designer, but it bears almost no resemblance to anything coming out of Redmond -- or anywhere else, for that matter.

PDesigner is quite different from anything that people might have seen back in the heyday of BeOS because, unlike them, the internal architecture is extremely general. An entire object system had to be created to wrap around each of the control classes available in Haiku. This object system is what sets PDesigner apart from the rest: the project that you are creating manipulates the control objects while they are running -- the GUI is live as you work on it.This might sound like a cool feature that doesn't have much use, but it makes possible something else: scripting from any language. PDesigner's object interface is string-based, so it's pretty easy to write bindings to the object system for any language you can think of. Last summer a group of students from the University of Auckland created a Python interface to PDesigner's object system.

I spent quite a lot of time over the long weekend getting out bugs and expanding its capabilities, such as good support for methods and working around some of the lack of flexibility inherent to the C++ language. Bolting methods onto an object is really easy now. A program of this size is definitely not something that'll be finished next week, but it will open up new possibilities. Here's a screenshot just for your enjoyment. TTFN :-)

Lesson 14: I Node What You Did Last Summer

2010-11-26T08:24:00.001-05:00

A holiday treat! In this lesson we continue to work our way through the Storage Kit, learning about one of the lesser-known features of the Haiku API: node monitoring. For those new to Haiku, it notifies programs of changes to the filesystem, such as changes in a name, etc. If you're looking to turn a good Haiku app into a fine one, this is one way to do it.

Programming with Haiku, Lesson 14

Lucky Lesson 13: Queries

2010-11-17T21:04:00.000-05:00

I'm not talking about databases, either. In this lesson, we examine one of the most distinctive features Haiku has: the query. We get a good, long look into the murky depths that are the query's official syntax, Reverse Polish Notation, and a few other weird and wonderful tricks. Enjoy!

Programming with Haiku, Lesson 13

Not Off the Radar Yet

2010-11-17T21:00:00.000-05:00

I can't even put into words how busy I've been the last few weeks. My last post was a little more than 3 weeks ago, but it has felt like an eternity. This past month or so I've had to deal with three separate incidents of a sick child and spending a week keeping the house running while the other half was busy being ill, as well. Not the least bit fun. School has been crazy busy with more than I care to enumerate here. It's been a lot, needless to say -- makes me wish for times that were much easier to find a few spare moments. I haven't given up and I haven't gone anywhere, but at least all two of you out there know what I've been up to. :-)

Lesson...12? All About Attributes

2010-10-26T07:48:00.000-04:00

You might think that I took a short vacation, but I've just been buried in Real Life. You might also be wondering about where lessons 6-11 went. They'll be published later, but you're not missing anything, as they are edits of the last several lessons from Learning to Program with Haiku with an experienced developer in mind. If you've worked with the previous series, there isn't anything in 6-11 that you haven't seen before -- they're more to make the Programming with Haiku series complete on its own. This lesson is all about attributes -- what they are, how they can be useful, and how they are manipulated from code.

Programming with Haiku, Lesson 12

Programming with Haiku Lessons 3-5: C++ Triple Play

2010-09-30T07:51:00.000-04:00

In an attempt to move on and get on to just the Haiku API, here are the final three lessons on C++. Lesson 3 introduces C++ file streams, formatting and printing using C++ streams, and lightly touches on exceptions. Lesson 4 takes a break from actual coding and spends time on a critical development tool: source control -- what it is, how it is used, and why it is used. Lesson 5 ties together all of the C++ concepts covered in this series with a project. I hope you enjoy them.

Programming with Haiku, Lesson 3

Programming with Haiku, Lesson 4

Programming with Haiku, Lesson 5

Klutzo Strikes Again

2010-09-23T19:59:00.000-04:00

As is typical for a geek of my athletic ability, I'm a near-total klutz. It's not uncommon for me to bang some part of my body on something each day. Last night I managed to do a real doozy: a computer bit me on the foot. Hard. It wasn't even mine, either. I'd brought home 3 different machines from school, 2 of which were left lying around for parts and the third was good except for a dead hard drive... or so I thought. The CD drive needed replacing, too.

The machine is a Gateway E series mini desktop which has a tool-free case -- fold up the top and pop off the front bezel and you can remove the CD drive and the hard drive. I foolishly left the thing sitting on the floor beside my computer desk, sans front bezel. Unfortunately, I kicked the thing and one of the plastic edges in the front put a nice slice into the outer side of my foot near my pinky toe. Ouch. A new low in clumsiness-related injuries in my life. On the upside, I can put a sign on it when I take it back to school: "CAUTION: this computer bytes. Use at your own risk." Yeesh.

Programming with Haiku, Lesson 2

2010-09-23T17:03:00.000-04:00

I had an unexpected day off from school today, so I took advantage of the time in getting a bunch of writing done. The result? Lesson 2 is available for your reading pleasure. In this lesson, we go on a fast and furious flight through the rest of the Standard Template Library.

Programming with Haiku, Lesson 2

Ohio LinuxFest 2010: Didn't Disappoint

2010-09-13T08:13:00.001-04:00

This weekend was my second year at the Ohio LinuxFest at the Greater Columbus Convention Center in downtown Columbus, OH. I arrived at the convention center at about 7:15am. Unlike last year, there was hardly anyone there outside of the OLF staff doing checkin and a few vendors. Joe Prostko was already there, having stayed at a hotel nearby the night before. It was good to see him again. We started talked for a bit and then started getting the table set up. I made sure that we had enough supplies for the table and each of us had brought a demo machine. Joe brought an MSI Wind netbook which was running a nightly build and I brought my Dell Latitude D620 running an almost-stock Alpha 2. Both machines proved to be valuable for demoing different aspects of Haiku that day. Soon enough we started seeing some traffic.

Most of the day itself was spent at the Haiku table talking to convention-goers. I even spoke with some people who I recognized from last year. Unlike last year, my laptop only KDLed once. Wanting to see what the sessions that were offered were like, I spent a little time in the Ubuntu on ARM session, which was quite technical but reasonably interesting. It gave me a clue about what to expect if I were going to speak at a session. I'm pretty sure that I'm going to give a session next year on Haiku. Mike Summers had managed to come, albeit later than last year. He rolled in about 3pm, but it was good to see him again. He might've been late, but his presence was felt, becoming the resident "chick magnet." All of us were surprised by that one. ;-)

The people that come to OLF are always really interesting to talk to and, being fellow open source fanatics, quite receptive to Haiku as an operating system. Many of them are intrigued by Haiku's boot times, feature set in combination with its hardware requirements, lack of an X server, and its unique features like queries and the extensive use of attributes. Joe had the Stack and Tile decorator running on his netbook and everyone who saw that were really impressed, myself included. Only those people who were familiar with BeOS or Haiku were not suprised by the number of movies playing simultaneously without dropping frames. My favorite demo was running 3 videos on one workspace, switching to another workspace to start a lengthy project build with Paladin, and switching back to show how responsive Haiku was even with the CPU maxed out. We've got a great OS here.

Some of the main questions that I ended fielding were about stability, where people could try out Haiku, and what Haiku offered in the way of an office suite. It would seem that right now, according to the conference goers, that having OpenOffice.org or KOffice or something is quite important. Perhaps someone might be willing to step up and finish the work on Gobe's Productive suite given this thought.

It was a great conference and I'm looking forward to the next one!

Update: A couple of photos taken while we were there.

Mike Summers and I, defending our table from the hordes

Joe smiles while I continue to blather on.

A New Series of Lessons: Programming with Haiku

2010-09-07T21:21:00.000-04:00

Since I started publishing my Learning to Program with Haiku lesson series back in January, I have, on many occasions, seen comments asking for lessons aimed at current codemonkeys who want to break into development for Haiku. Here begins a new series of programming lessons aimed at people who already have a basic grasp on C++: Programming with Haiku.

The direction of the series is pretty straightforward. First, we'll be spending some time (i.e. the first unit) delving into some less-commonly-used features of C++ which show up in Haiku from time to time. This is partly to bring up to speed those who are picking up the series after finishing the first one, but also to examine ways that features like containers from the Standard Template Library can be effectively used in combination with the Haiku API. There's even a quick primer on source control thrown in for good measure -- something which any developer should at least understand, if not use religiously. Following the first unit we will dig into the API. Depending on how things work out, there may or may not also be a crash course on GUI programming in there before diving into the kits themselves. Some of the lessons will deal directly with getting to know a particular kit. Others will examine important topics or the "Haiku way" of getting a task done. They should provide a good working knowledge of Haiku development methods that can easily be expanded into more advanced usage.

While I have a basic outline for the series, it's very general and I'm not exactly sure how long the series will run. It certainly will be quite a while, though. A word of warning: my school schedule is completely insane from the start and I will not be publishing largely on a weekly basis like the first series. Instead, I'll be posting them when I am able. I really like writing these things, so they'll happen, but it may take some time. Now, without further adieu, Lesson 1, which starts by looking at templates and some of the containers in the Standard Template Library.

Programming with Haiku, Lesson 1

Learning to Program with Haiku Color e-Book Available

2010-09-06T16:50:00.000-04:00

My first book on learning how to write programs using the Haiku operating system is now available as a color e-book. Until now, it has been available in print and for download, but only in black and white. Unfortunately, this lacks the syntax highlighting for the code that the original programming lessons had, but it was initially necessary because color printing costs at Lulu.com are exorbitant in my opinion and publishing the book in color would have made it prohibitively expensive. E-books have none of these limitations, so without further adieu, it can now be downloaded $10 from its own page on Lulu.com. The original black and white version is still available for those who would prefer it.

Learning to Program with Haiku, Color e-Book Edition

Another Serving of News Soup

2010-09-04T17:31:00.000-04:00

Aside from the new Stack and Tile decorator that Clemens Zeidler just made public, there isn't much going on this weekend in the Haiku community. I figured I'd pass along some minor news from the last couple of weeks.

Next weekend I'll be heading off to the Greater Columbus Convention Center to help host a Haiku table at the Ohio Linux Fest, armed with Alpha 2 CDs, flyers, a demo machine, and a bunch of other stuff. I'm looking forward to the time. It was a busy, but fantastic time last year.

A couple of weeks ago a news post was made to HaikuZone about my book. As part of a collaboration effort with Jorge Mare (a.k.a Koki) and some notable Japanese developers in the Haiku community, Learning to Program With Haiku is going to have a special Japanese edition published. There is also some discussion of a Spanish translation, too, and Haiku contributor Kurain is in the process of translating my programming lessons into Chinese. I'm flattered to see some of these opportunities arise -- when I was writing the first few I never thought these would be as well-received as they have been.

As if it weren't already easy to install -- at least if you ask me, anyway -- Paladin is also on its way to becoming an optional package thanks to the effort of developer Scott McCreary (scottmc). The neat part is that -- at least at the moment -- it's possible to build the current 1.3 release or build straight from the sources in Paladin's Mercurial repository on Sourceforge. Pretty slick, if you ask me, and props to Scott for pioneering the effort!

Since the 1.3 release, I've been working on a self-extracting packaging system. It's similar in many ways to the packages used in Zeta 1.2 and 1.5, but creating them can be done using PSfx, a graphical program which closely follows the interface of the PackageBuilder tool which comes with the BeOS 5 Development Tools archive. These packages can also be created from the command line, and this ability is one of the main motivations behind the system. The system is still under development, but it's showing promise. I can't wait for it to be ready, if for no other reason than to make the next Paladin release go from sources to release package in one command, which would be really sweet.

School's back in now, and instead of primarily performing custodial duties like I've had the last couple of years, I'm back to doing what I love most: teaching music. I very much have a full load, so coding is pretty much limited to the weekends, but I'll be working on stuff like this packaging system as I'm able. Best wishes to all of you in whatever you do. :)

Tip: Add / Set Resources Easily

2010-08-27T19:23:00.000-04:00

For those unaware, Haiku applications have certain information stored in resources. This includes the version, short and long descriptions, and a duplicate of the signature specified in the application object's constructor. You can easily set this information quickly by adding an .rdef file, which is a text-format resource file.

To quickly create and edit this information, add a new file by pressing Alt+N or choosing Add New File from the menu and enter the name of the .rdef file, such as Resources.rdef. Double click the file's entry and when it opens, you will be greeted with a text file where you can fill in the information for your application with a minimum of fuss.

Editing .rdefs not to your liking? Make a Resources.rsrc file instead, right-click on it, and choose "Edit Program Settings" to do the same thing with the FileTypes app. Either way, simple and fast. That's the way we like it. ;-)

Introducing Paladin Tips, Symbol Finder

2010-08-18T07:38:00.000-04:00

Paladin has grown quite a lot since its inception. In fact, it has a lot more features than BeIDE now. I worked extensively with the venerable tool when I was reverse engineering the .proj file format. Having gotten accustomed to Paladin, BeIDE seems kind of sparse. Some of Paladin's features aren't necessarily as obvious as others, so from time to time, I'll be posting tips on making your use of the IDE better, faster, and more convenient. What better way to work more effectively than from the author himself. :)

The Symbol Finder tool was introduced in version 1.3. It's a search engine for libraries. Did you ever have a time when you were receiving linker errors for a symbol that was missing, but you couldn't figure out which library it was in? Symbol Finder to the rescue. It's kept in the Tools menu, but it's also a separate application, too. Once started, enter the name of the symbol and hit Enter and it will search all of the libraries in the system library folders for it. Any hits will pop up in the search results.

Haiku Alpha 2-based Paladin Build Available

2010-08-15T15:44:00.000-04:00

After yesterday's release fiasco, I quickly reinstalled Haiku using the alpha 2 branch in the source tree and while the version number hasn't changed, the Paladin 1.3 packages available via the links in my previous release post will work on alpha 2. My apologies for any inconvenience this oversight has caused. We now return to our regularly scheduled program. ;-)

Building Paladin from the Source: Not Necessarily a Bad Idea

2010-08-14T19:25:00.000-04:00

It never dawned on me that people might want to install Alpha 2 and continue to use it. Personally, I can't fathom not using a nightly. I'm big on stability, but considering that Haiku is very much in an alpha state, I expect problems. Some revisions are better than others. Right now, one of my machines is running r38082, which is a nice, reasonably stable build, but it apparently has some symbols that Alpha 2 lacks. Looks like I'll be putting out an Alpha2 build tomorrow. ;-)

Using development builds of Paladin are not normally what you might expect of a development build for other projects. I don't use release builds of Paladin -- I use the bleeding edge. If something breaks, I un-break it because otherwise I can do any further Paladin development. Using a development build of Paladin also tends to have newer features and fixes than can be found in the releases.

If you want to continue to run Alpha 2, that's fine. I'll be posting an Alpha 2 build soon. Here's how to build Paladin from source. You'll need Mercurial installed to do so.

From the Terminal run these commands:

hg clone http://paladin.hg.sourceforge.net:8000/hgroot/paladin/paladin
cd paladin
buildsuite.sh

This will actually build Paladin, PalEdit, and parts of the as-yet-unreleased packaging system and create a package on your Desktop. Open it and it will install Paladin on your system. If you want to use ccache or fastdep, copy them from the Paladin install folder to /boot/common/bin. The bug causing them to be installed in the wrong place is the reason why the packaging system isn't officially released yet.

Release Day: Paladin 1.3 is Out!

2010-08-14T15:39:00.001-04:00

It is my pleasure to announce the next version of Paladin, now available from Haikuware and DarkWyrm's Library. Although it has only been about four months since 1.2.1, a lot of work has gone into this release. Probably the single most noteworthy feature in this release is source control integration. Although it is just at a basic level at the moment, commits, diffs, and other common tasks are either a keypress or a couple of clicks away. Subversion and Mercurial are supported with Git support in development. BeIDE projects can now be imported. ccache has been updated to 3.0.1 and now dependency checking can be done with fastdep -- much faster than gcc's dependency checker. Some (accidentally) broken features, such as Run in Debugger and the Program Settings item for resource files have been fixed. Projects in the Start Window can be opened from the list using Alt + a number key, so Alt+1 opens the first project in the Recent Projects list -- this little feature has made a big difference in my own ease-of-use while using Paladin.

Some features didn't make this release, which I'm kind of bummed about, but I'd much rather get a stable release out now than a buggy one or a stable one 6+ months from now when I sort-of have time during the school year. The release doesn't use the new packaging system because I just couldn't get it stable enough in time, but Paladin 1.4 should use the new system. I can't wait for that because with it I can literally build the entire Paladin suite from source and package it with one command using a shell script -- truly One Command to Rule Them All.

As always, bug reports are genuinely appreciated. Enjoy!

Update: The binaries require at least Haiku r38082 because of some of the bugfixes that Paladin depends on.

Crunch Time with Surprises

2010-08-08T22:15:00.000-04:00

It almost sounds like I'm eating Lucky Charms, but it's true. 1.5 weeks until school starts and already I'm getting my mind into that mode. I've gone into testing mode for Paladin so that, hopefully, it will be ready to ship by the time that school time hits. I've found a few weird things, but there's just a lot of stuff to test and use day-to-day. I had plenty of chance to break things in this weekend. How?

I spent Friday night in a daze, just playing around with unzip, curious if there is a way to create self-extracting zip files in Haiku and Linux. It turns out that it is. Literally it is just a matter of tacking on a zipfile to the end of an stub program which more or less runs unzip on itself. This led to a realization that hit me like a lightning bolt while I lay in bed early yesterday morning. For a while I've had code that I wrote for a packaging system for BeOS / Zeta / Haiku sitting on my hard drive, collecting proverbial dust because I couldn't figure out the best way to store the files. It was a large percentage of the way to completion, too. This connection put me into coding overdrive yesterday and I spent a generous amount of time on it tonight, too. The result? PSfx. Of course, this isn't news if you subscribe to the checkin RSS feed for Paladin. Natch.

PSfx is a package building app which works very much like the PackageBuilder app which is bundled in the BeOS 5 Development Tools. The difference is that, when finished, it will work *much* better than PackageBuilder and won't require any extra tools. The new format uses ZIP compression leading to smaller file sizes than the equivalent for SoftwareValet packages. Like Paladin, it has a scripting-friendly command line interface, perfect for integrating into other build systems or hacking together a quick shell script to automate the building and packaging of a project. The build scripts that it uses are a similar format to the Paladin project files, which makes them friendly toward source control and also easy to read and write even with just a regular text editor. Also, even though the executables will run only on certain OSes, it will be possible to build, say, a Haiku GCC4 package from my Zeta install.

All of this is not to say that it's finished, however. While the install engine and command-line interface are mostly finished, the GUI still needs more work. There are some bugs I need to fix and some other miscellaneous stuff needs done. While PSfx certainly won't be ready for the Paladin 1.3 release, Paladin's next release, in theory, will use this new install system. While these self-extracting packages probably won't be as elegant a solution as what the other Haiku developers will be coming up with at the proper time, it sure beats waiting a few more years for decent software distribution tools.

More Fixes and Features for Paladin

2010-07-28T21:40:00.000-04:00

I spent a great deal of time today doing more hacking on Paladin, a trend I've had the last week or so when I wasn't working on getting my book out the door. The Code Library feature, for now, has been withdrawn until I can get it working well, which it just doesn't right now -- everything works the right way except for synchronization, which is the entire point behind the feature. The code for it is still there, but it won't be enabled for the next release. I fixed several really annoying bugs, including workarounds for two bugs in Haiku which took a lot of effort to find but were trivial to work around once found. One of them is project files being mistakenly identified as plain text files.

Source control is the star feature for the next release. I intend to make it about as easy as possible to integrate source control into a developer's workflow as possible. It took me a long time to really "get it," but now that I do, I want others to have an easy time using it without having to learn command line syntax until they're ready to do so. The only thing that I currently have on the to-do list before the release is to polish and test the different ways that source control is used. Once that's done, I'll be putting out a release. I really love this project -- the rewards are incredibly satisfying. :)

Learning to Program With Haiku Now Available in Book Format

2010-07-22T11:36:00.005-04:00

The book is finally done! Getting through the proof copy took *so* much longer than I ever expected. Luckily, right now I'm out of town with a lot more time on my hands, so I had a lot more time to be able to sit down and get through it. It has been published through Lulu.com so that a great deal more of the profit from the book goes to me instead of the pockets of a book retailer. Here is the link to the book and e-book.

Learning to Program with Haiku at Lulu.com

The regular price is $25 USD, but as part of the launch of the book, it is on sale for 15% off the regular price through August 15 when you use the coupon code BEACHREAD305 at Lulu. It will also be available through online book retailers like Amazon.com, Barnes and Noble, and others, but it will be a couple of months before it appears on those sites.

If you've been a fan of the lessons and want to show appreciation or to have a copy of it on your desk while you work your way through, now you have a chance to have a high quality copy, and if you've been sitting on the fence about it, read a lesson or two and then decide for yourself. Enjoy!

Paladin: No More CVS, Either

2010-07-15T12:55:00.004-04:00

I wish that when I started the project for Paladin over at Sourceforge that I had been able to choose Subversion for source control using the client for Zeta. Because of an outdated client, I was forced to use CVS. While CVS is (barely) adequate for legacy work, anyone who knows the importance of source control knows better than to use it when far better tools exist. Subversion is CVS done right, but it certainly isn't perfect, either.

Distributed source control tools are the current fashion, it seems, and rightly so. After a lengthy discussion of Mercurial vs git which to choose over Subversion, I decided to do some looking into both of them. It's another one of those Coke vs Pepsi, KDE vs GNOME kind of controversies. Long story short: I haven't looked into git very much, but I've learned enough about Mercurial to say that I like it a lot.

Just a few moments ago I checked in the current development snapshot to Paladin's new Mercurial tree. It's official: I'm no longer using Zeta for development. I am still supporting source compatibility for the platform, but now my focus for Paladin is solely Haiku. This change in perspective will bring in some features not possible for R5 or Zeta.

One new feature for Paladin 1.3 is integrated source control on a basic level. The inspiration comes from The Joel Test: 12 Steps to Better Code. One of the steps is using source control -- yes, even CVS. In all the years that I've been flinging C++, I never used source control locally. I didn't see the point in doing so locally and didn't think all that much about source control to begin with. I didn't want to put in the effort to learn more, either. Lazy developer, I know. git and Mercurial make it foolish to not use it. It's a different workflow, but only slightly.

Paladin's integrated source control will be simple and about as unobtrusive as possible. It creates a repository when you make a new project. Click a menu item or press a shortcut on the keyboard, type in the check in message, and it will check in your work locally. Click another menu item and it will push your changes to another repository somewhere. It's about as painless as it can get. Mess something up? Revert to the last known good revision. You will be able to even choose from Mercurial, git, and Subversion for your work. Only the basics will be covered in 1.3 to avoid pushing the release off too much. Gotta get back to hacking. TTFN

No More Hangs for Paladin

2010-07-10T20:43:00.002-04:00

Those of us who run Haiku under a multicore machine can finally breathe a sigh of relief. For about as long as I can remember -- probably as long as it's had multithreaded builds -- Paladin has suffered from problems with locking up under Haiku. There never was a problem with it when I was developing Paladin from within R5 or Zeta, though.

Over the last couple of days, I've been doing some serious development on Paladin from within Haiku and one product of said hacking has been Haiku bug #6288. I've been working pretty closely with Ingo Weinhold on the problem and he was very kind in teaching me a few system-level tricks along the way, particularly with the kernel debugger. The result? Revision 37460 patches the problem. Considering that several bugs that Paladin development has exposed are still open AFAIK, I'm really thankful for Ingo patching this one -- I wouldn't have had a clue where to begin.

All of this effort I've been putting into Paladin this week has resulted in some new features and bugfixes. Running a project in the debugger now works again following a patch to both Terminal and Paladin, for example. I'm going to finish one major feature, see if I can fix problems in the code library, and start going into the test phase for a new release. I haven't a clue when that release will be, but, worst case, it should be here by the time I have to go back to school next month, barring major problems -- hopefully much, much sooner. Until next time. :)

Not Worried About Haiku's Future

2010-07-08T08:44:00.002-04:00

Operating systems are funny things. They take FOREVER to develop, for example, and I don't just mean Haiku. Look at the development time for Vista. It took a multi-billion dollar corporation for than five years to write the upgrades for XP.

There's also a chicken-and-egg problem that fledgeling OSes have: how to get an OS without applications and how to get applications without an OS. Luckily for Haiku, a lot of that problem has been mitigated by BeOS' startup history. The QT4 port just saw a 4.7 release. I'm really thankful for the efforts of those guys. Other people like Michael de Vincius Oliviera and the HaikuPorts team have been hacking away at porting stuff from other platforms. While they certainly don't have all of the BeOS goodness of a native app, at least we have some of these apps and games. KOffice takes a team of dedicated developers that is IIRC larger than our OS team alone. We're really starting to get a lot of useful apps.

Stability has always been my sticking point for coding under Haiku, but at least in my experience of late, Haiku's been pretty stable, all things considered. I'm typing this from a GCC4 hybrid build that I installed from sources. So far Paladin hasn't been plagued by deadlocks like it has been in the past, which has led me to believe that it was never Paladin's problem in the first place, but the jury's still out on that one. I'm even working on more features that will only work under Haiku and fixes for the platform, like using rsync to properly synchronize modules for the code library. In the last couple of days I worked with a couple guys on the team to nail down a bug in Terminal which was preventing Paladin from running applications in the debugger. After patching both Paladin and Terminal, it works beautifully now.

Feature-wise, Haiku is even now doing an admirable job of playing catch-up. People in the past have mentioned that R2 would be the release where Haiku would implement all the features that BeOS was missing that all the other OSes have, but more and more I don't think it'll take that long. OpenGL stuff might, but the Google Summer of Code has been good for that. There have been other people who couldn't wait that long for stuff like WiFi, so even now that partially works. Simple amazing, if you ask me. Then again, even though it's been slow, Haiku's progress from the outset has been that way, too.

The Book is This Close

2010-06-30T09:54:00.003-04:00

After about a week of what felt like futzing around with my book, Learning to Program with Haiku is just about published. I ordered the proof copy this morning, so in about a week I'll have a hard copy of my work, and barring major problems, it will be available for the general public, both in dead tree format and as an e-book. I'm really excited!

More PalEdit Progress

2010-06-25T19:54:00.004-04:00

For those who didn't know, I've been finally getting around to cleaning up PalEdit, Paladin's text editor. It is based on Pe and in its current publicly-available state, isn't all that different from Pe. I'm in the process of fixing that. On the surface Pe is a great all-purpose text editor. I'm not that fond of it personally just because I only write code in C++ under Zeta and Haiku with rare stints into Python land under Ubuntu.

When I started working on Paladin, I needed a text editor to go with it, and Pe won over Scintilla for quickly getting things going. Since that time, I haven't really done much with it aside from some integration with Paladin's build system -- that is until now.

The actual code for Pe is a mess. I've mentioned multiple times my disdain and loathing of the resource system that it uses and the tool that compiles them, rez. Rez is hard to use because the errors it generates are not at all helpful and it merely compiles C-like text file into regular resource files. Very few of the extensions are actually useful, and with Paladin being specifically a C/C++ environment, all the extra languages used are unneeded. Internally, the archictecture also needs cleaned up, especially the code that handles the syntax highlighting for the different languages.

Rather than rewrite the thing, which is foolish, I've been doing some major refactoring of the code. The result at this point is a stripped down editor with syntax highlighting that is one quarter the size of the current PalEdit executable. It still needs quite a bit of work to be feature complete and there are bugs still left to squash, but when finished, it will be much easier to add stuff on, to maintain, and to also embed into other applications. It will be possible to finally integrate the editor into the rest of Paladin, whether or not I do it remains to be seen, though.

Lesson 23: Polish and Packaging Our Project

2010-06-22T20:21:00.002-04:00

This lesson finishes up the project that the last two have been about: HaikuFortune, a program which randomly chooses and displays a fortune in a window. It's not a very complicated one, but it exemplifies a reasonably well-coded real-world project. Although it was code complete as of the end of Lesson 22, it was not finished, missing icons and other resources. This concludes the project with adding resources, a basic discussion on source code licensing, and packaging a program for Haiku.

Learning to Program With Haiku, Lesson 23

This also concludes the Learning to Program With Haiku lesson series. It's been a good run. Rest assured, though, that this is not the last lesson on Haiku programming that I will write. This series has been intended to turn a motivated power user into a developer using Haiku. It's been a lot of fun and many people have encouraged me with their kind words regarding it.

Later this summer I will start another yet-to-be-named series which will continue where Learning to Program With Haiku is leaving off and introduce novice and intermediate developers to real coding specifically for Haiku and its nuances, such as multithreaded programming, add-on coding, queries and attributes, Tracker and more.

In the mean time, I am working on revising the lessons into a complete book available for a reasonable price in dead tree and possibly e-book format. These PDF lessons will continue to be freely available and redistributable. More details to come soon.

Lesson 22: Designing a GUI

2010-06-14T21:52:00.002-04:00

Usability is one of my pet topics. Although less so now that in years past, it is all-too-often ignored or not given enough priority. This lesson scratches the surface from a developer's point of view. I'm no usability expert, but I do know a thing or two. This lesson is a must-read for any budding developer, and by the end of it, we will have a good real-world program to show off which is just shy of being ready for a release.

Learning to Program With Haiku, Lesson 22

Project Sources: 22HaikuFortune.zip

Lesson 21: Reading and Writing Files

2010-06-11T13:59:00.002-04:00

This lesson continues with delving into the Storage Kit, reading and writing files. We also start writing code for the final project of the Learning to Program With Haiku series which will be developed over the course of several lessons.

Learning to Program With Haiku, Lesson 21

Count Me Flattered

2010-06-06T07:24:00.002-04:00

I just won Haikuware's 17th along with Pier Luigi Fiorini for my work on Paladin and all of the programming lessons that I've been publishing. My Haiku golf shirt came yesterday and it looks really nice. I didn't start either one to achieve any recognition, but it's really nice to be appreciated. Thanks everyone!

Lesson 20: All About Storage

2010-06-01T19:52:00.004-04:00

Moving on from exploring the Interface Kit, we turn our attention to the Storage Kit in this lesson. We take a look at the kit from a broad perspective and also begin using some of its many of the classes. We take a break from writing GUI applications and, instead, write a console directory-listing program using C++.

Learning to Program With Haiku, Lesson 20

Source Code: 20ListDir.zip

Lesson 19: Resources and Pictures

2010-05-25T08:20:00.005-04:00

Ten years ago when I first started to learn to write code using BeOS, I had a lot of questions that I couldn't any documentation to give me the answers. Luckily, there was the Be Code Talk mailing list and kindhearted members of the community, like David Sowsy (Animaxo, Vesa Accepted). Resources are one of those things that eluded me. Eventually I figured them out, but Lesson 19 lays some of it out in plain conversation.

Learning to Program With Haiku, Lesson 19

Sources: 19Emo.zip

PalEdit's All in Pieces

2010-05-24T19:23:00.002-04:00

All over my floor.... or something like that. I spent most of the weekend ripping apart and putting back together pieces of PalEdit in a separate folder -- code that hasn't made it into the tree yet. Yesterday afternoon I had successfully refactored the code for the text editing view. It's possible to type and delete text, but that's about it -- even little things like the arrow keys don't work yet. Syntax highlighting is disabled for the moment, too. That's OK, though. Those features will get their turn, too. The big accomplishment is that I'm pretty sure that the hardest part is over: reducing dependencies until all I have left is a BView which I can type code into. This will enable all sorts of nice things like the possibility of a tabbed interface, properly-implemented split views, and more. I'm getting a better handle on how most of the code works, too, so I *might* be able to implement my #1 most wanted feature: code completion. We'll see. :)

Lesson 18: Working With Lists... and Other News

2010-05-19T07:36:00.007-04:00

We're starting to get closer to the end of this Learning to Program series. After toying with menus and interface colors in the last lesson, we apply some of the concepts used with menus to get the hang of using list boxes and discover along the way a few bizarre sports that really exist. Games people play. Sheesh.

Learning to Program With Haiku, Lesson 18.

Sources: 18ListTitle.zip

In other news, I've been running a little slower with the lessons as the school year winds down -- 12 school days and counting as of today! It's a little tougher to get the time and motivation to write when time's tight and Valve released Portal for free. Sometimes it's a tough choice. ;-) I've also been spending time -- mostly on the weekends -- doing some serious hacking on PalEdit. The more I work with it, the more I discover that it's like going to the Olive Garden: high-quality spaghetti. I managed to rip out all of the rez resources (yay!) and strip it down to pretty much bare metal.

Right now I'm in the process of refactoring the sources so that source code editing is encapsulated into a single BView. This has helped immensely with my understanding of how to write a text editor. It will also enable tighter integration of the editor with Paladin's project management and hopefully enable me to figure out how to implement code completion, the one sorely-missing feature on my personal hit list. I guess we'll see.

Lesson 17: What's on the Menu?

2010-05-10T08:17:00.003-04:00

After an unintended wait, Lesson 17 is finally out. We are back to learning about hacking on the Haiku GUI after taking a short C++ language break. Today's topic? Menus. Also in this lesson is some expansion of what we know about messaging and BViews.

Learning to Program With Haiku, Lesson 17

Project: 17MenuColors.zip

Happy Reunions

2010-05-02T07:43:00.002-04:00

It's been official for about a week or so now, but I haven't had any time to do anything with it. I've rejoined Haiku. My life is a lot different from when I left, and people were glad to have me back. It's kind of strange how there's often a disconnect between people who don't live far apart, but never get to see each other for whatever reason. This is very much like that. No matter.

My first act was to patch a crash when clicking on the leaf menu when the Deskbar was stretched across the width of the screen -- "Start Menu" mode. Axel made a bigger patch based on it, so I'm happy. Now I'm going to see if I can get the system colors that are tweakable via Appearance to actually make color changes across the system. It's actually the fault of the controls in the Interface Kit, not Appearance, so we'll see what happens on that one. Should be interesting. :)

It's good to be back.

Lesson 16: Locked and Overloaded

2010-04-26T19:57:00.003-04:00

It's strange how a week goes by so quickly now, but it's good motivation to keep writing! This lesson takes a break from hacking the Haiku API to learn a few C++ language concepts needed to continue progress as an aspiring developer. Function overloading and operator overloading are examined in detail. Enjoy! Learning to Program With Haiku, Lesson 16.

Lesson 15: The Haiku API at 10,000 Feet

2010-04-20T08:58:00.003-04:00

Having written our first program, Lesson 15 delves further into what writing basic applications are all about, looking at the API and its organization and focusing on an essential: messaging. Also included in this lesson are the finished sources for those who don't want to mess around with typing the project out.

Learning to Program With Haiku, Lesson 15

Lesson 15 Project Sources: ClickMe.zip

Lesson 14: Our First GUI Program

2010-04-13T19:38:00.002-04:00

It's about time: our first program which does more than print stuff to the Terminal! Now the real fun begins! Learning to Program With Haiku, Lesson 14.

Paladin 1.2.0 Released!

2010-04-04T20:46:00.005-04:00

It's been more than a little while since the last release, but I'd say that it's been worth it. Beyond the usual round of bugfixes, it's about as stable as 1.1, which is a great thing for BeOS and Zeta users, and a bit of a bummer for Haiku users -- there is a known bug which hangs Haiku on what seems to be multicore machines when running a build that I haven't nailed down yet. It's a tough one, but rest assured that I'm working on it.

Time-saving features are the highlight in this release. It is possible to create and/or utilize templates of common application types, such as an app with a main window and a menu bar. An Import Project feature in the Start window makes quick work of making a Paladin project from existing sources. The compiler cache ccache can be used in Zeta and Haiku to speed up builds. There are rare build issues for the Zeta version, so it is not enabled by default for stability's sake, but most people will want the speed gains. A regular expression tester has been added to the Tools menu to save a few gray hairs from testing regular expressions in applications.

I've still got some tricks up my sleeve, so don't be surprised by a 1.2.1 or even a 1.3 release by the end of summer. I can think of a few more features that would make my workflow even easier, so I'm pretty sure they'd be of benefit for everyone. Until then, happy coding!

Paladin 1.2.1
Paladin 1.2.0 Sources

Update: As it turns out, PalEdit 1.2.0 crashed under Haiku GCC4 hybrid builds and had some icon issues, so 1.2.1 is out and the link updated accordingly. The sources haven't changed, however. :-)

Lesson 13: Programming With Class(es)

2010-04-03T20:41:00.002-04:00

Today we'll be diving headlong into the murky depths of C++ programming: classes and inheritance -- struct's with fancy tricks aplenty. It's also our last lesson before writing our first windowed Haiku program, so get ready and study well. Enjoy! Learning to Program With Haiku, Lesson 13.

Lesson 12: OOPs, I Did It Again!

2010-03-28T07:28:00.005-04:00

This would be the only time I will capitalize on a really bad Britney Spears reference. I promise. ;-) This lesson introduces us to the wonderful world of C++ and Object Oriented Programming. It's not terribly code-heavy, so this might be a good time to look over past lessons to make sure you understand concepts pretty well -- it only gets bigger from here. :-) Learning to Program with Haiku, Lesson 12.

Fast Access to All of the Lessons

2010-03-21T08:42:00.005-04:00

I've put up a page on my old website, redesigned and now renamed DarkWyrm's Library, which has one-click access to all of the programming lessons that I've written. If you've missed one, this would be the place to look, saving a lot of hunting on this blog or the one over at the Haiku website. This is also a good place to find all of the apps that I've written. I've also got links posted here for when this post is buried by others so that you don't even have to bookmark them. Gee, how kind of me. ;-)

Lesson 11: More Data Structures and Types

2010-03-20T11:50:00.002-04:00

This time around, we will be examining some important kinds of data structures and ways to create custom data types, a critical stepping stone in getting to understanding the Haiku API. This is the last C / C++ lesson -- the rest will be C++ only. A couple more lessons and we'll finally be ready to write GUI programs for Haiku! Enjoy! Learning to Program with Haiku, Lesson 11.

Lesson 10: More Pointers and the Command Line

2010-03-12T20:56:00.002-05:00

Here it is: Learning to Program with Haiku, Lesson 10. Now we're starting to tie up loose ends before moving on to just C++. In this lesson, we learn more about pointers and kinda-sorta pointers called references, and we examine the basics of getting information from the command line. Also included are the answers to the review questions for Unit 2.

Changing OSes: Harder Than You Think

2010-03-11T20:02:00.003-05:00

I have had experience in a wide variety of operating systems over the years -- every version of Window$ except 2.0 and NT 3.5, DOS 3.0 - 6.0, Linux distributions, MacOS 7.5.3 - OS X, BeOS R5 through Haiku, and even a little QNX. It dawned on me yesterday that this actually colors my perspective significantly. As proponents of alternative operating systems, we need to be aware of how hard it is to change your primary OS.

Think for a moment about what using Windows is like: always being on alert for viruses, perpetual security updates, going to the Geek Squad or a friend / relative for fixes, Microsoft Office, buying a PC loaded with bloatware, Photoshop and other can't-live-without-it apps and so on. It's a way of life, and an inferior one at that, but that realization comes only if you are made aware of better options. Let me repeat part of that: it's a way of life, as in a culture. Not that I've done it myself, but I know enough to know that changing your primary OS is very much like moving to another country.

Consider the differences in what you know about the United States, England, and Australia. Last time I knew, there weren't too many koalas climbing trees in Willesden Green, for example. I'm not even going to comment on the "Chocolate Thunder from Down Under" server at Outback steakhouses here in the States -- I've never had it -- but I do know what it is that Australians call a thunderbox, and the only thing it has in common with chocolate is the color. Eeew. Riding a lift is something I might expect a construction worker to do, as in driving a forklift, but that's not what it means across the pond. They all speak the same language, but there is a lot of difference even though there is a lot of common ground beyond language.

Imagine for a moment moving from your home country to another one which speaks the same language that you do, but one you've never visited before. Which would be more difficult: packing everything and leaving on the next plane out of town or spending time there and planning your trip, possibly having a house in both places for a while? Without a doubt, the harder option would be the first one, but sometimes we, who have successfully done that in a computing context, mention it without hardly a second thought -- "Just use Linux (or a Mac, or whatever). It's easy!" That's like saying to my neighbor who has lived her entire life in the town I live in to move to Australia without any regard to all, if any, of the implications that this entails.

Changing your primary operating system is something that takes time, effort, and patience. The change requires willingness to put in effort to learn something new, even through the problems and inconveniences that will arise. Total beginners actually have an easier time than people who "don't know much about computers" but they still require a lot of help. Keep in mind that truly helping people requires an investment of your life into theirs.

Whole Lotta Lessons Goin' On

2010-03-05T20:52:00.001-05:00

There have been quite a few comments on people being excited about when these start addressing the Haiku API, so I'm going to speed things up a bit. I originally planned on calling this week a Buy One, Get One Free week, but that won't fit now. I had planned on publishing review questions after Lesson #5, but I must have forgotten to upload them, so I'm making them available along with Lessons 8 and 9 and the questions for review after Lesson 9 has been completed. Here they are in order. Enjoy!

Lesson 7: Losing My Memory

2010-02-26T19:52:00.000-05:00

It's hard for me to believe that I've been publishing these mostly-weekly lessons for almost a month and a half. It's been really fun. I hope that those of you reading them have been enjoying reading (and hopefully learning from) them as I have in writing them. This one covers two major topics: memory management and binary math, nothing terribly exciting, but really useful and necessary nonetheless. Learn to Program With Haiku, Lesson 7.

Lesson 6: More Loops and Conditions

2010-02-19T20:23:00.000-05:00

Here marks the beginning of the second unit in my series, "Learning to Program With Haiku." Lesson #6 expands on our knowledge of loops and decision-making constructs. Good luck! Learning to Program With Haiku, Lesson 6.

Paladin Release Delays... a Good Thing??

2010-02-13T21:44:00.000-05:00

Normally, you'd consider it a bad thing when a software release has to be pushed back. I was thinking of pushing out that release I mentioned earlier this past afternoon, but it's not going to happen.

I just kind of fell into a coding session this afternoon and this evening and it yielded some great results. I managed to get a well-known Linux tool, ccache, built for Haiku and Zeta and tweaked Paladin to take advantage of it. I did some testing on my P4 3.0 Ghz with hyperthreading (a dual processor machine to Haiku) with a copy of the sources to FtpPositive that I had lying around. The results completely blew my mind.

Build Type	Build Time
single-threaded, uncached	13 seconds
multithreaded, uncached	12 seconds
single-threaded, cached	~3.5 seconds
multithreaded, cached	~2.25 seconds

That's an 80% improvement with build caching! For small projects with only a few files, it doesn't make nearly that big of a difference, though. The bigger the project, the bigger the boost, it would seem.

I also found a few bugs that I managed to squish that were related to a feature that I implemented during the snow days I had earlier this week and discovered another one which needs to be taken care of plus some more general testing before a release can be made. When it's all done, though, this will be a really nice improvement over the last development release and a huge leap over the stable branch.

Programming Lesson 5: Arrays, Strings, and Pointers

2010-02-12T21:39:00.000-05:00

It's that time of the week! This is the end of the first unit of lessons... about halfway to writing our first GUI program for Haiku. Some more advanced concepts, especially pointers, are found in this one. Enjoy! Learning to Program with Haiku, Lesson 5

Lesson 4: If, For, And, Not, Or

2010-02-05T18:31:00.000-05:00

Hey, that rhymes even! Lesson 4 is now out. Decision-making and repeating instructions are on the agenda for this one, expanding the repetoire of basic skills for writing code. Learning to Program With Haiku, Lesson 4.

New Paladin Release Coming Soon

2010-02-01T20:17:00.000-05:00

At least in the last week or so I found the coding motivation that I seemed to have misplaced. I did some hacking on Paladin and was amazed at how easily a couple of features came together. I *finally* managed to make drag-and-drop group reordering work correctly. This has been a feature that I've been personally missing since drag and drop was implemented in the project window. There's even a visual regular expression tester that's been added to the Tools menu.

The feature that's holding things up is the Code Library. The concept? Encourage (and in my case, simplify) code reuse by creating modules of code that, once imported into a project, remain synchronized with the master copy. It's a little like source control, but on a more basic level. It seems simple on the surface, but it's turning out to be more of a challenge than I thought. I personally plan to use it a *lot*, so I'm waiting to get it right before the next release.

Third Lesson and More

2010-01-29T19:44:00.000-05:00

Yep, it's that time of the week. Out for study is Learning to Program with Haiku, Lesson 3. Amazingly, I seem to at least temporarily come out of my total lack of coding motivation. I've been doing some Paladin-related hacking. It feels nice to have the desire again. Hopefully it will stay a while. :-)

Programming Lesson 2 Out

2010-01-21T21:53:00.000-05:00

As promised, here is the second lesson in the series. The first lesson was all about taking the first baby steps, such as what a program is and what functions are for. Now we take a look at comments, a little bit about dealing with errors, and 10,000 foot view of how a compiler builds a program. Enjoy! Learning to Program With Haiku, Lesson 2.

Branching Out

2010-01-16T18:38:00.004-05:00

Sometimes I have plenty of useful stuff to say that really isn't appropriate for this particular blog, so I spawned a second blog, DarkWyrm Unabridged. There's even something to read over there now, too. If you ever wanted to know more about me personally, that would be the place to do it. It still needs some work on making look like a regular blog (as opposed to the cookie cutter variety), but it's a start.

Calling All Haiku Developer Wannabes

2010-01-15T07:54:00.002-05:00

Have you ever wanted to learn to program for Haiku (or something else) but never had the money or the chance? Has something else gotten in the way? Even though I still don't have any real motivation to work on Paladin or write other code, right now I have plenty of motivation for writing about code.

I'm going to be publishing online programming lessons whenever I have some time. Usually this will be about one per week, but may happen more or less often on occasion, depending on how my spare time runs. These lessons will be available in PDF form under a Creative Commons license that will give me some options should I ever want to publish them in dead tree format.

Considering that I write fairly well and I've been teaching for more than 10 years now, this is quite an opportunity for someone who wants to learn to code. To kick things off, here's the first one. Learning to Program With Haiku, Lesson 1.

Do BeOS and Zeta Matter Any More?

2010-01-03T13:36:00.003-05:00

I just got to thinking the other day (yeah, nasty habit, I know) and I've started to wonder if R5 and Zeta really make a difference any more. BeOS R5, patched or otherwise, is just shy of 10 years old. In the land of Redmond, that's the difference between Windows 98SE and 7. Ouch. Hardware that will run it is increasingly hard-to-find, as well -- unless you run it on a recycled machine, at which point you run into hardware reliability problems at some point.

Although it's only been 2 years since the final release of Zeta, it's also been declared illegal via piracy, so current users are on shaky legal ground at best when using it. It also has a number of compatibility problems with R5 and Haiku, as well. Hardware support has been kind of funny in my experience -- some machines will run it and others not at all. There isn't any binary compatibility with Haiku with anything compiled on Zeta, either, which adds hassle to developers.

Although Haiku has made great strides, it is still buggy, and unless it sees a serious influx of developers in the near future, it will be for quite some time. Should developers even bother with writing code with R5 and/or Zeta in mind? Vote on the poll at the right and let's see who runs what. Maybe that will give a better answer than my own musings. :)

Taking Some Time Off

2009-12-21T19:53:00.003-05:00

In case you hadn't noticed, there hasn't been any news out of the ol' DW skunkworks. I haven't really had the desire to do much of anything with BeOS or Haiku the last couple of months, but, frankly, I'm not sure why. Some of it just seems absolutely futile--a chasing after the wind, to quote the book of Ecclesiastes. The thought of writing code almost leaves a bad taste in my mouth... that so much time and thought is poured into something which works well for a time, but also requires maintenance to keep running properly: a total lack of desire or motivation.

I've been here before. The last time I felt this way, it was burnout. There is a distinct possibility that this is the case again, but it feels different this time even though I can't quite put my finger on it.To put it succinctly, I'm puzzled. This may be just a pause in the journey, but only time will tell.

Thought for the day: when you're at the bottom of a well, don't forget to look up. :-)

OpenOfficeMouse: An Epic Fail in Usability

2009-11-08T07:35:00.007-05:00

Having been down for the count with a back injury for the last week, I'm a little behind the curve in keeping up with the news. I just learned about the OpenOfficeMouse, an open source mouse designed for use with the OpenOffice.org office suite. Upon seeing the picture, I couldn't believe my eyes and didn't want to, either.

This mouse is a usability nightmare and it's so ugly, it's oogly. If you don't want to mess with the press release, I'll give you the lowdown: it's a mouse with 18 buttons, 3 modes, a joystick on the side with 3 modes of its own, tons of optional extras, and tweakability beyond anyone's dreams or worst nightmares. When I first saw a picture of it, I couldn't believe my eyes that someone would come up with a product this bad. Warmouse did.

I've seen quite a few comparisons with Apple's Magic Mouse. I'm not going to go there -- it's been done -- but what I will do is detail what's wrong with the OpenOfficeMouse. There's quite a bit wrong with it, too, and I'm not even referring to its appearance.

The buttons... oh the bevy of buttons available on the OpenOfficeMouse... where should I begin? It's almost as if OOM is a cross between a keyboard and a mouse, possessing two groups of seven buttons with the two primary buttons on the outer corners. The only differences between any of the buttons in each group are minor: slight shape differences, location, and, in the case of the primary buttons, color. It would seem that the designers forgot that a mouse is generally used by touch, not sight.

One original mouse idea went around at the Xerox Palo Alto Research Center (PARC) where it was designed. The concept, if you ask me, was very forward-looking: its three buttons had a different color and texture so that you could tell which button you were pressing by how it felt under your finger but easily specified on screen, e.g. red-click. Aside from the mouse becoming more rounded to fit the hand, not much else has been done to significantly change mouse usage since its inception at the PARC.

Button collections aside, there is also yet another major flaw in the mouse: the abundance of modes. Changing application behavior based on a button press or a checkbox is not generally a good idea because the user needs to adjust his actions according to the mode in use. Adding more kinds of modes places more mental load on the user. More technical users generally don't have a problem with this, but the difficulty they impose increases with the user's lack of expertise. Without appropriate feedback on the current mode -- considering the design flaws elsewhere in the design, is unlikely to be the case -- the different modes available both on the joystick and on the mouse in general will probably cause plenty of input errors, as well.

The intention behind the OpenOfficeMouse is to improve the experience of using the OpenOffice office suite faster and/or more easily. Unfortunately, unless you're an incorrigible tweaker, this mouse isn't going to help. The solution is to fix OpenOffice. Software is MUCH more malleable than hardware.

Pondering the Next Moves for Paladin

2009-11-04T22:13:00.002-05:00

It's been quite a while since I reported on any development I've been up to. There hasn't been much, but I have been doing some Paladin hacking. For probably a month now, I've been attempting to figure out what direction Paladin development should take. The development branch has received some changes to add support for different project types. If I remember correctly, BeIDE had something like this which it called stationery. There is also a code library feature which has pretty good potential, but I've noticed some major architectural issues in its synchronization code and also in other areas. The only problem is that there is other code, such as the Project class, which needs significant changes in order to make it work well, so I've begun doing some experimental refactoring. The nice thing is that I'm building in some more flexibility into the code. It should make for a more powerful build system... it should also be interesting to see how well all this works out. TTFN, dear readers. :)

Karmic Koala is out...shrug

2009-10-30T07:17:00.005-04:00

I was really excited last April when Jaunty came out. This time...not so much. Don't get me wrong, I like the new release, and the machine I'm typing this from is upgraded to it pretty quickly, but from the perception of Joe User, it seems more like an LTS upgrade. Here's what I've seen that's new:

First, there is the usual shiny. The icons are different. This version includes some nice wallpapers, and the boot process was made shinier by replacing Usplash with Xsplash. Of course, there is just this odd-looking Ubuntu logo while you're waiting for it to appear. The Xsplash screen is just plain gorgeous, but vaguely-beige logo that shows up beforehand is at least one step back. It's just ugly.

Once again, boot times seem to have been improved. I can't put my finger on it and I haven't bothered to time the differences, but it certainly feels faster.

A few new apps and some changes to existing ones. Network Tools adds some standard tools like pinging and port scanning, but nothing that wasn't already easily installed by those who needed it (or skipped if using bash). The Disk Utility is a nice addition, but it's only a mild improvement over gparted -- SMART information and a different way of looking at the partitions. The Ubuntu Software Center is even simpler than Add/Remove Programs was. As if IM using Pidgin was hard, as far as I can tell, Empathy makes A/V chat easy. A bunch of programs received upgrades, such as Firefox to 3.5 and OpenOffice.org to 3.1. Aside from these kinds of things, nothing earthshaking.

One notable exception to the otherwise nice-but-not-groundbreaking list is Ubuntu One. Now by default there is cloud storage. For cheap power users like myself, the 2GB storage is just a drop in the bucket and with the US economy being in the toilet, spending $10 or $20 a month for extra storage just isn't an option unless you *really* need it. Dropbox has the exact same storage costs and is cross-platform, unlike Ubuntu One. If you need cloud-base file synchronization with at least one Window$ box, this is a much better option. Still, Ubuntu One is nice, too.

Maybe I was expecting more because some of Canonical's previous releases have been major improvements. Karmic Koala is more of an incremental improvement. There are other big fish to fry, such as simple remote desktop access with FreeNX or a decent entry-level desktop publishing -- sorry, Scribus doesn't cut it in this case. Yes, these are "merely" apps, but there are plenty of improvements that can be made. I'm hoping Lucid Lynx makes some real headlines, but for now, I'm quite content with Karmic.

One More Feather in Haiku's Cap

2009-10-10T14:02:00.003-04:00

At the end of last week, I ordered a new computer that came about the middle of this week. It's an Athlon II 2.6 Ghz quad core system. I was so excited about it coming, and now that I have it, it feels like a Ferrari compared to either of my other two machines. Zeta doesn't run on it very well, so that's a small bummer, but Haiku runs perfectly... no, unbelievably. It just gets out of the way. How well? I ran 4 instances of the Haiku3D demo at the same time, and all 4 CPUs were only at 50%. Compiling the Capital Be beta from source with the development Paladin took what seemed like no time and didn't even come close to maxing out all four cores, and as far as I could tell, it couldn't compile faster because gcc was I/O bound. Not only the Haiku run well on old or low-power hardware like netbooks, but it is even better on fast machines.

Making Up for Lost Time

2009-10-04T21:51:00.003-04:00

As if it weren't already obvious, I'm not off the radar yet. ;-) Just one day after the 1.1 release, I spent this evening hacking on Paladin and adding support for project templates. I never really bothered with it until tonight when I wanted to hack together a quick-and-dirty development tool and wasn't happy that I had to write some more boilerplate code. Bleah. I'd toyed with the idea long ago, but didn't bother for some reason. It's nowhere near what I'd like for customizability, but works pretty sweet for saving some initial project creation time, so here's one nice feature for 1.2. :)

Capital Be... It's About Time!

2009-10-03T17:05:00.003-04:00

As you can see, I'm working on tying up some loose ends. Years ago, I said that I was going to open source Capital Be, my personal finance application. I meant it... I'm just a little late. ;-) Like all of my other projects, it's MIT licensed. I may keep updating it, I may not -- all that really needs done to be *really* useful is to finish the budget variance report code, which isn't all that easy, unfortunately. Perhaps OFX online banking support isn't even out of the question. Only time will tell on this one. :)

Paladin 1.1 is Out!

2009-10-03T15:22:00.003-04:00

Normally, a simple release wouldn't be particularly newsworthy, but this is one I'm pretty excited about: the current unstable branch was released. This is the version that I've been coding with (and on) for the last several months. There are lots of internal improvements, such as better startup time because it stores dependency information in the project file. A host of small interface tweaks have been added, as well. One that I use pretty frequently is the opt-out for creating a folder for a project -- great for migrating projects to Paladin without much extra effort. Using drag and drop to add entire folder hierarchies to a project is a great time-saver, too.

My favorite feature of the release, though, is the code library. It started because I have quite a few classes I've written over the years which are shared between my various projects, but because I don't have a dedicated source control server (something I've been considering more and more lately), keeping these classes in sync with the occasional changes that I've made is more than a little bit annoying and error prone. Check a few classes into the library as a module, and Paladin automatically synchronizes the code.

Ohio Linux Fest... What a Ride!

2009-09-26T19:44:00.005-04:00

Well, for not having been doing hardly anything Haiku-related in the last month or so, this kind of made up for it. It all started with almost not getting a table at the conference and then on Wednesday--if I remember correctly, that is-- suddenly having one by the power of Greyskull, um, I mean Koki. ;-) This meant a flurry of e-mails, burning what remaining CDRs I had around the house, quickly putting together a Haiku demo machine, and a host of other details.

I arrived at the Greater Columbus Convention Center at about 7:15 am to set up and was quickly met by Michael Summers, whom I've known since the first WalterCon years ago, and Joe Prostko. We had been concerned about not having a projector, particularly on such short notice, but as we found out, it wasn't really necessary. We had a six-foot table, Joe's MSI Wind netbook, my Thinkpad R40 laptop, some live CDs, a bunch of fliers Urias had sent us, a couple of chairs, and some great neighbors in the non-profit section: the Northeast Ohio Open Source Society (NOOSS) and The Linux Link Tech Show (TLLTS). Setting up didn't take long, and even at that early hour there were already a lot of people there besides the sponsors.

I'd never gone to a computer convention like Ohio Linux Fest before, so I wasn't completely sure of what to expect. It wasn't all that different from some teacher conventions that I'd attended early in my teaching career. The big difference was that I could talk about my favorite operating system with the people around me and they'd actually understand me. :)

To be honest, I wasn't really expecting the kind of foot traffic that we received during the day. The table was in a great location and I can't even remember the number of people that I talked to during the day, let alone Joe and Mike. The live CDs that Joe and I had made didn't last long at all and despite starting with plenty of fliers, after about four hours I ended up running to Kinko's to make some copies of our last one.

After reading about others' experiences at similar events, I thought it was going to be a long day. Nothing could have been further from the truth. The whole day was a blur of talking with great people. It goes to show you that time really flies by when you're having fun.

Having been through my first convention, I'd like to share some of the insights I've gained. First, this is a really exciting time for Haiku. It runs circles around the competition in terms of the feature set in combination with its ease-of-use, low hardware requirements, and performance that it offers. On a machine like a netbook, there is no comparison. The small storage footprint and ease of configuration give Haiku potential for a sort of OS toolkit, similar to how Linux is used as a base for tools, such as CloneZilla. The demand for something like our favorite OS is there. All we really need is critical mass.

Working Harder than Before in the Office

2009-09-11T07:44:00.004-04:00

This school year sure has been a busy one. Like last year, I'm teaching computers, but unlike last year, I'm teaching junior high and high school students. No rugrats for me this year, which is a bummer. I like the students I have -- especially when I taught most of them when they really were rugrats -- but I love teaching little kids. The courses? Office and typing. Bleah. Luckily, teaching Office 2007 isn't so bad because I'm also teaching OpenOffice.org right alongside it. Time is tight, but some of them are getting it.

I haven't written a line of code since school started. :( I'm having to learn the Office curriculum I'm teaching, which has been sucking up a lot of time. I also need to expand my IT skills, so I've started studying for an MCSA. Just so you know I haven't drunk the Redmond brand of Kool-Aid, right before I started I had been working on learning CentOS administration, which I still plan on learning. The upshot of the studying is that just in the last week (which is when I started) I've managed to put to use immediately almost everything I've been learning. All of this has seriously cut into my coding time, but with the potential for more money, this is a Really Good Thing (TM).

I'm still planning to go to the Ohio LinuxFest, but I don't know if Haiku will be able to get a table. I'll find out later today, so I guess we'll have to wait and see. Even if we don't get a table, I'm still going and pushing Haiku from the other side of the vendor table. Heh. *evil grin*

Ohio LinuxFest, Here I Come!

2009-09-01T20:35:00.004-04:00

After a little prodding, I've decided that I'm going to be one of the guys manning the Haiku booth at the Ohio LinuxFest. It's been held in Columbus for a few years now. Last year there was talk of going, but I couldn't swing it because of all the crazy stuff going on at work. It should be an intersting time, and after 4 years of not doing anything like this with Haiku (WalterCon '05), I must say it's good to get back to having some fun with Haiku again.

CloneZilla: More than a Ghost of a Chance

2009-08-22T20:16:00.007-04:00

School started for the teachers at my school last Wednesday, so no code for me. :( However, there has been an up side to it all. To make a long story short, I get to teach some junior high and high school computer classes and had a need to image a total of 10 laptops. In the past, I used Norton Ghost 12 and recently upgraded to 2003. Both were provided by my school. Never again, however. While I was in the middle of waiting for a machine to be imaged, I did a little looking around Wikipedia for alternative software, having never heard of any alternatives or bothered to look for any. There is a wonderful alternative: CloneZilla.

What is CloneZilla, you ask? It is a Linux-based Live CD project which does the same basic stuff has Norton Ghost 2003 (and a lot that it doesn't), but is free software and -- as far as I can tell -- faster, too. Both allow you to back up your machine to one big file and then clone others from that file. CloneZilla, however, is quite a bit more technical than Ghost, which tries to market itself as both a backup solution for the regular user and a sysadmin's imaging tool. With that said, CZ is quite technical, and there were quite a few options that I had no clue what they were for. It was a wise idea for those behind the project to incorporate both a beginner and an advanced mode. The latter is well-named!

Some of the other things that I really thought were nice to have: backup can be done via SSH, NFS, or Windows file sharing (Samba) or to a local disk. Quite literally, you could clone a machine from the Live CD and a flash drive! Maybe I'm just really happy because Ghost 12 leaves you using PC-DOS and 2003 sticks you with the Vista pre-install environment. While for different reasons, they're both junk. It took 2003 probably a good 5 minutes to boot and the CZ disc about 2. Multiply that by 10 machines and you have something significant.

One thing I did not test out was the server version of CloneZilla. It comes as a part of Diskless Remote Boot Linux and requires loading a machine with Linux to act as a server to handle booting over the network. If the testimonies on the project's website are any measure, not having to buy the ~~expensive~~ enterprise version of Ghost coupled with the speed of cloning up to 100 machines over the network at the same time is nothing short of phenomenal.

This is not to say that working with CloneZilla is all wine and roses. I did run into one major problem with my first attempt. The first image I created with it was done over the network to a disk I was sharing from Windows XP. The image had somehow gotten corrupted when it was created. However, I made a new one to a USB hard drive I had lying around and it was all fixed from there on.

I can't stand Norton's antivirus package, but Ghost is a solid product. CloneZilla feels like it's based on Linux, full of technical terms and a slew of unfamiliar options. Guess what? When it comes to price, speed, and hardware compatibility, Norton seems to lack the spirit.

Haiku Alpha: More than Pleased

2009-08-17T09:26:00.005-04:00

I am *so* glad about the appearance of the alpha at last. It's something that I've wanted for myself and the community for a long, long time. Let's hope that there is an influx of developers into the community -- in the words of Michael Phipps, Haiku itself is a slow but steady train and while there are plenty of apps out there thanks to BeOS' legacy, there are some key ones missing, such as good office software.

What kinds of applications are we, as a community, missing? Major ones.

Word processor - the AbiWord port is by no means complete. Productive was lightweight for 2000. It's not even really worth mentioning almost 10 years later.
Spreadsheet - Sum-it, now that it is open source, is missing features that many office workers need.
Personal Information Manager - I hate Outlook. Haiku needs something better that fills the void. E-mail is covered with BeMail and Beam and contact management (mostly) with Mr. Peeps, but there is no good, easy-to-use calendar program. Sunbird isn't stable enough to count.
CD Burning - Helios is the only good one, but it's dead in the water because it's closed source and won't even run on Haiku. Melt is only open source one, it's hard to use, and its code is a mess.
Photo manager - Think of the many things that Picasa does. BeAndSee in combination with PhotoGrabber is a step in the right direction, but, as a community, we're not there yet. Wonderbrush is a great image editor, but it doesn't to photo-related work like red eye removal or color adjustment.

There are websites that let you do almost all of those, but there are a great many times when you don't have access to the Internet. What do you do then? If you dual boot with another OS like me, you reboot to another OS. If not, you're pretty much stuck.

If you're a developer and even remotely committed to Haiku, find a project, get behind it, and help. Don't know how to code? Try learning. If a moron like me can teach himself how, anyone can learn. I'm not in the realm of Axel or Ingo, but, then again, I didn't go to college for computer science, either.

What if you don't want to learn to write programs or can't for some reason? Help developers in the community by using their programs and telling them about your experience. I don't know about other developers, but it makes me feel good that something I wrote is helping someone else and I want to know about bugs. I probably don't know about some of them. It takes a some time to write a few e-mails, but not nearly that of writing programs, and it helps everyone. Have a blog? Test and review some software. Tell other people of your experiences with it. Can you write well? Help work on documentation.

In some ways, I'm getting a feeling around the community that is probably similar to the days of BeOS DR9. The community is quite small and most people I talk to have never heard of BeOS, let alone Haiku, or they heard of it once and that's it. What makes open source work is people giving back, and not just developers.

Windows Responsiveness (or Lack Thereof)

2009-08-14T21:09:00.004-04:00

It's official: I really have gone off the deep end -- at least if you talk to anyone from Redmond. BeOS ~~fanatic~~ zealot that I am, I'm acutely aware of the responsiveness of an operating system's desktop user interface. I expect my computer to run slower if I'm hitting the hard drive or processor pretty hard. I also expect programs to NOT take several seconds to respond to input or to redraw themselves. My experience with OS X is pretty shallow in comparison to my usage of various Linux distributions, BeOS and its variants, and all Windows versions save Media Center and 2.0 -- yes, I there was a time where I twiddled with Windows 1.0. Nonetheless, to my recollection, I have never seen Windows respond to the user very well even on a machine far beyond the recommended specs.

After spending the summer with my work laptop running Ubuntu, I had to install XP Pro. I didn't want to, but my school is a Windows-only shop. I disliked doing the install and resented having to hunt all over the Web for drivers only to have to install 500MB of system updates, but the last straw was when I was copying over my MP3 collection. Both machines were running XP and the file copy was taking forever. After about fifteen minutes, I rebooted the source machine into Linux, deleted what little had been copied, and started copying the collection using FileZilla to do an SFTP transfer. I had two files being copied at once and each one was taking half the time to copy as the XP file copy had. Somewhere in there, there's a problem. Worse yet, the destination machine was so slow (Athlon 64 3000, 512MB RAM, 80 GB hard drive) as to be unusable. Just plain sad. Man, I'm going to dislike using this machine with Windows again. :(

New Paladin Stable Release and More

2009-08-14T07:28:00.003-04:00

Well, I finally got around to getting the patches I've made to the stable branch out the door. I actually was planning on doing it a little while ago, but BeBits and Haikuware were down, so it seemed kinda silly to do it then. Anyway, it fixes a couple of minor bugs plus a couple of major annoyances. Anyone who has done any development in Haiku with Paladin has discovered that projects don't keep their file type, which is very much like trying to walk a mile with a rock in your shoe. This is a bug in Haiku (#3231) that hasn't been resolved, but I *did* manage to find a way to work around the problem. Libraries in /boot/common/lib also show up in the library window. These two patches make developing in Haiku a lot more pleasant.

I'm not just standing still on Paladin's unstable branch. I'm working on what will probably be the last feature before I release an official build: the code library. What in the world is that, you ask? A feature itch I've had for some time which is now getting scratched. The C++ computer language lets you write code with reusability in mind. I have a bunch of files which I use quite a lot in my projects. The only problem is that if one of those files gets changed, I have to go through all my other projects that use the same files and update them, too. Paladin's code library eliminates this by keeping its own copy and updating projects when you open them. It's a little like using version control (CVS, Subversion, etc.), but much less work for this kind of task.

Despite its name, the unstable branch right now is pretty stable. It should be interesting to see some of the bugs that other people find once it's released. TTFN

Happy Everything

2009-08-03T08:12:00.003-04:00

I just recently discovered this picture as a really cruddy jpeg file with lots of artifacts. I liked it so much that I spent several hours yesterday redoing it in Inkscape. While there are small differences, they're not very noticeable. I'm posting the results here so others can enjoy it, too. You can click on it at the left and save it (PNG, 1280x1024 for desktop wallpaper) or save the SVG version.

Extracting Clipart from the Office Website

2009-07-28T15:37:00.004-04:00

Despite things like the recent GPL-licensed(!) contribution from Redmond, Micro$oft is not well-known for being friendly toward the open source movement. One example is the clipart available on the Microsoft Office website. It's an excellent resource for teachers and office workers. With the Office 2007 clipart manager dead in the water with Crossover Office and Wine last I checked, getting clipart to make newsletters and such in Linux is a problem.

The problem is that clipart from the Office website is downloaded in MPF files. These are simply XML files with the actual file data base64-encoded. There is a Perl script to extract the files, but it requires several modules to be downloaded from CPAN. Not too horrible for me, but definitely not something that, say, the secretary at my church would be able to tackle. No more. I have written a GPL-licensed Python script, mpfextract.py, to extract all clipart from MPF files. This'll also be a nice thing to have once Haiku has WMF support beyond having libwmf ported. :)

Time Flies When...Aw, Who am I Kidding?

2009-07-14T15:42:00.002-04:00

The last couple of weeks have been pretty fast, but I don't feel like I've done a whole lot. Most of my time has been spent painting my living room. Luckily, I finished it the middle of last week. I've spent the time since then applying and sanding drywall mud. Today I had 5 1/2 hours of joy: putting primer on every surface in the sun room save the carpeted floor. Bleah.

I do have some good news, though. Frustrated by the lack of a decent packaging system, I've created a self-extracting package. It looks and works much like the installer for SoftwareValet's packages. The nice thing is that these can be invoked to install from the command line, so using this system could be ideal for distribution makers. Now all I have to do is write the tool that puts files into a package, which was the reason for starting it all. I also need to do a public beta of a self-extracting package, so don't be surprised if you see a Paladin release of some kind in the near future. :)

Still Here

2009-06-30T15:44:00.002-04:00

Yep, all quiet on the front, but not for any bad reasons or anything. I've been spending quite a lot of time working on the renovations in my house. Last summer, my wife and I started working on fixing up our house for when we finally decide to sell it and move closer to work. My living room was in a nice state of plaster covered with drywall mud when school started. 9 months later, I got back to working on it. You know you're in education if your life is school 9 months of the year. I can safely say that it's about 75% done -- 3/4 of the room is completely done and the other 1/4 isn't much beyond having the walls stripped and ready to start with mud. It'll probably be pretty close to completely done by the end of the week, thankfully.

Codewise, I'm still working on the GUI designer foundations -- list controls, buttons, and checkboxes work right now. There is still a ton of work before it's worth using for anything, but I'm not giving up. I've been working a bit on the development branch of Paladin, too.

The last couple of days I've been working on an alternative using SoftwareValet packages. The reason? Release time for Paladin is a major pain in the neck, mostly because the same set of procedures needs done each time and they have to be done manually. This, on more than one occasion, has led to mistakes in the package, in the build, or something else. This goes back to one of Joel Spolsky's questions in his 12 Steps to Better Code article. If you've not read this article and you are either a developer or work with one, you should definitely read it. To save the rest of you who don't want to bother, you should have it possible to make a build -- from checkout to compiling all the targets -- in one step. The BeOS platform doesn't have something like that... yet.