Older blog entries for deven (starting at number 6)

Well, I don't know what's going on, but the system isn't acknowledging any certification for me anymore despite the NINE certifications currently listed on my public page. :-(

I was going to reply to nmw's post in this article about LISP and interned strings, but I guess I'll have to "reply" here for now. He said "Try doing that in Python, or Perl, or Tcl. You just can't, [...]" Well, I wondered about that, so I thought about whether something of the sort could be done in Perl, my preferred HLL.

Here's what I came up with:

  my($sub, $space, $name) = $AUTOLOAD =~ /^.*:((?:(.*)_)?(.*))$/;
  $interned_value{$space}{$name} = int($interned_value{$space}{""}++)
    unless exists $interned_value{$space}{$name};
  eval "sub $sub { $interned_value{$space}{$name}; }";
  goto &$sub;

The idea is to reference undefined subroutines like &foo_bar in the program, and the AUTOLOAD routine would create a new subroutine returning an integer index to use for a scalar array. The final underscore (if any) in the name would determine the namespace; &foo_name and &bar_name could end up with the same value. (The idea is to avoid wasting entries in a scalar array; think of "foo" and "bar" as structure names.) Once defined, the subroutines would continue to return the same value, which is kind of like interned values in LISP.

I don't know if this is actually faster, though. The subroutine lookup may well be slower than a hash lookup would be. However, this could be VERY useful to conserve memory if many similar data structures are used; using scalar arrays with interned symbolic indexes would be more space efficient than using many hashes with string indexes. (Hopefully a later version of Perl may have a more natural and efficient way to do this sort of thing.)

This isn't a perfect solution, but it does show that Perl is more flexible than it may appear at first. Of course, since Perl is pretty damn fast to begin with, tricks like this usually aren't necessary to get decent performance. Even with its more natural interned symbols, I doubt LISP can approach Perl's performance in general...

Okay, I was a little rushed to catch my bus the other day, so I didn't bother to put a link. The Kuro5hin story, "Release often, sure. But early?" would actually be an interesting topic for discussion on Advogato. Since there's already a discussion underway on Kuro5hin, if anyone has good ideas for me, I urge to you reply to my posting that I copied into my previous diary entry...

The RSA patent expires today! Okay, it's a moot point, since RSA released the algorithm into the public domain 2 weeks early as a P.R. stunt. Regardless, it's a Good Thing (tm).

The rest of this diary entry is a copy of a Kuro5hin.org posting, subject: "I wonder how common this problem is?"

I've been struggling with similar issues. I've got a conferencing system (fairly different from IRC, but similar idea) which I started writing in 1992. I've spent far more of the time since then not working on it than I've spent working on it. Nevertheless, it's about 10,000 lines of C++ code at this point, and it does some clever things.

I originally wrote the system as a simplistic tool to chat in real time with several family members, avoiding long-distance costs. It evolved over time to a halfway capable imitation of an older conferencing system I used years earlier at RPI. It's not quite as sophisticated yet as the experienced users of RPI's conferencing systems expect, and the interface seems arcane to many who are unfamiliar with those systems. Accordingly, there are only a small handful of regular users.

Currently, the source code is unreleased. I've often considered releasing it as free software (i.e. Open Source), but never quite felt ready to do it for a variety of reasons:

  • The project never felt close to "done", and I've been reluctant to release it while I have a mile-long TODO list.
  • I'd like to be able to use the code as an example of the kind of work I'm capable of, but there are some serious defects in the design and coding that I'd want to fix before it can be the caliber of example I want.
  • Between things I want to fix and things I want to add, there are some major architectural changes likely. Involving other developers makes this more difficult.
  • At the same time, releasing the source usually suggests accepting patches from others, which would dilute the code; right now it's 100% my own code; diluted code wouldn't serve as well as an example.
  • I never seem to find enough time to work on the project, and maintaining a full Open Source project with all the ancillary bits (website, CVS server, mailing list, etc.) takes time.
  • I'm concerned about trying to build and maintain a userbase. It's harder to find motivation to add features and fix bugs when few people will ever benefit from it. Releasing the code would enable someone else to "steal" users with my own code, especially if I don't find time to compete with any potential forked codebase.
  • I've wondered if there's any potential to make money from the code, that might not be possible if the source is freely available. I still wonder about this, but I'm not convinced it's worth pursuing. I'd rather find a way to make money on it as an Open Source project, if possible. Meanwhile, I do have a day job.
  • And, of course, I simply haven't gotten a Round Tuit (tm).

After recent reflection, I've concluded that my best course of action would probably be to release the code as Open Source, but not under the GPL at this time. I don't want to encourage a code fork, and I want to be able to maintain a pristine version of the code for now; I don't know that I'm ready yet to incorporate outside code and start the dilution process. I could maintain a patch pool of outside patches and possibly my own code fork, my code vs. the patched version. The QPL seems like the most appropriate license at the moment; I'd consider switching to the GPL at a later time.

Even so, I need to find some time to audit the code for things I really don't want to be seen, and to clean up some of the ugliest kludges, and to get the infrastructure setup, etc. I don't know when I'll find the time, but that's basically my current thinking.

Anyone have any thoughts or suggestions for me?

(Back to Netscape 4.72; still some annoyances with Mozilla, such as the fact that the Aphrodite package doesn't seem to be working...)

I'm tired from hearing (from ncm) about how awful it is that I self-certified as anything but Apprentice, because I don't have significant free software code contributions to point to yet. However, I can't in good conscience self-certify as Apprentice, because the vast majority of that description is totally inaccurate. Accordingly, I have removed my self-certification entirely; it seems the only acceptable solution. I'll re-certify myself as "Journeyer" when I have significant code to point to.

I don't appreciate being singled out for these attacks. I did the best I could with a very poor metric. Maybe I misjudged it. Aren't people (especially newcomers) still allowed to make mistakes? (Evidently not.)

According to ncm, any self-certification I choose besides Apprentice "reeks of arrogance". That makes every option unacceptable, which is why I removed the certification. Do I claim to be free from arrogance? No, I won't try to claim that. Am I more arrogant than average? Maybe in some areas, certainly not in others. Does it matter? Richard Stallman is one of the most arrogant people you could ever meet. Linus Torvalds is one of the most humble people you could ever meet. Both are acknowledged as Masters in almost any respect you'd care to consider. In the end, does it really matter?

Yes, I will make significant contributions to free software. Of that I am certain. I can't say for certain when, but I will. However, until I have something significant to point to (and maybe beyond then), I am staying out of this self-certification morass. I'll leave it for others to judge and incur the wrath of the Certification Police...

I guess I'll give Mozilla M17 a chance for a while. I hope I don't regret it like last time...

[Argh. Yesterday's Mozilla snapshot just crashed on me, and I was well into constructing a diary entry and a reply for an article. *sigh*]

Since some people were apparently offended that I "requested" Master certification, I have re-certified myself as "Journeyer". I suppose that's a better balance anyway. I believe my computer skills are strong enough in general to justify a "Master" designation, regarding that metric. However, my visible contributions to free software have been minimal as yet, as I noted as much in my first diary entry. By that scale, I might be an "Apprentice". So I guess "Journeyer" is a reasonable compromise. At any rate, I never requested anything.

I have been serious about programming for over 20 years, since at least sixth grade. (I had more casual exposure to computers and programming for several years prior to that as well.) Back then, I used BASIC as my primary programming language, since there were few other options available to me. (At that time, on a minicomputer at a nearby high school; I took a programming class that year for access to a computer, not to learn anything new.) By seventh or eighth grade, I was also working with Z-80 assembly language on the TRS-80's the school had.

In ninth grade, I also started using BASIC, Pascal and TECO on the RSTS/E system available at the high school, which was a PDP-11 (I think) that was owned by the town. I literally learned the Pascal language (including the use of structures and pointers) in one week by reading a textbook cover-to-cover in ninth grade. While I continued to use BASIC through the rest of high school (it was the most suitable language available for the platforms I was using), I much preferred the power and cleaner expressiveness of Pascal over BASIC.

TECO was a strange text editor and an even stranger programming language. It was psychotic but an interesting challenge in its own way. I've still got a printout of the most interesting TECO program I ever wrote, which renumbered BASIC programs (line numbers and references to them, including ON...GOTO and ON...GOSUB); it's about half a page of code printed, and it's dated May 1984 or so. One of these days, I'd like to scan in this TECO code and put the image on my homepage. I might even deconstruct it in an HTML page to show how it did what it did, but it would take a lot of analysis after so many years. Maybe when I find some time to waste on it...

Sometime early in high school, I got an Atari 800 and learned Atari BASIC and 6502 assembly language. My first exposure to the C language was "Lightspeed C" for the Atari 800, but it was a very limited environment. (I bought the K&R book around that time to learn what the real C language was like.) Although I didn't own an Apple ][, friends did, and later the school, so I did a fair bit of programming Apple BASIC also. I even had some exposure to QNX and Altos UNIX during high school, as well as dBase and the Clipper compiler. (I even played with LOGO at one point, which seemed useless but amusing.)

To give you an idea of the depth of my interest in computers, I purchased a copy of the "Dragon" book even before I graduated high school, because I was interested in learning about compiler design.

My computing life was completely overhauled in the fall of 1987 when I went to college at Rensselaer. That's when I got introduced to SunOS and the Internet. I immediately stopped programming in any dialect of BASIC and never looked back. C became my preferred programming language, and UNIX my preferred operating system. (BSD flavors such as SunOS 3/4 in particular.)

Unfortunately, I'm out of time at the moment, so I'll have to continue this story later...

[This is a little strange. I wrote this on July 27, but when I noticed a typo and fixed it, the system now calls it July 31. Sigh.]

I visited this site a few months back, and found the trust metric system very interesting. I always meant to look into it further, but maybe you're familiar with how things you put off can miss the back burner and end up on the floor behind the stove, forgotten? (I have this feeling I'm mutilating metaphors, but such is life.)

Life is too busy. It's inescapable. I never find all the time I need to do the things I want to do. Obviously, I want to do more than I can hope to find time for, even in the best case scenario. I have countless computer-related interests I'd like to pursue. At the same time, family time is a top priority. Yes, I would get more programming done if I didn't have a family, but I wouldn't give up my daughter for anything in the world. (I've already lost one daughter to "SIDS", 14 hours after she received 6 vaccines. But that's a long story...)

I worried a bit about what level I should certify myself at, once I finally got around to creating an Advogato account today. At risk of coming across as arrogant, I certified myself as a Master, albeit with some trepidation. Basically, I feel that I have very strong skills, but (due to that lack of time problem) I haven't visibly participated in the free software community to the extent that I've been emotionally involved in it.

One reason is a personal project that has been under development since November 1992, yet remains unreleased. Another reason is that my employer from July 1996 to March 2000 had a draconian intellectual property agreement that basically kept me from doing any outside work of any significance. (That, and they overworked me enough that I didn't have the time or energy anyhow.)

I've long viewed myself as a member of the community (since about 1987, when I first discovered GNU software and Unix), but my public contributions have been relatively limited. I'd like to change that, but I haven't quite figured out how best to go about it. There are a number of projects I'd like to help out with and/or create, but I've got very little free time to do any of it. My (living) daughter is 10 weeks old today, and demands (and deserves) much of my attention. (My first daughter died at 9 weeks old.) It's hard to figure out how to prioritize what little free time I can find.

The long-running project mentioned above is a CMC (Computer-Mediated Communications) system named "Phoenix". It started out in November 1992 as a simple chat program for the sole purpose of talking to family members that had Internet access. (To save long-distance charges, of course.) It evolved into a fairly robust backend single-threaded select-based TCP/IP server with a text-based user interface (which some consider primitive) based on an older CMC called "CONNECT" that I used to use when I was at Rensselaer Polytechnic Institute (RPI). (CONNECT predates IRC, and I grew quite used to the interface, but I've had others tell me they can't stand it.)

I could talk for quite a while about the existing features of Phoenix, but I haven't the time. Suffice it to say that my time was scarce enough during the original development that what could have been a couple months of development work stretched out over nearly 4 years, often with months between even minor code updates. It was completely dormant for the duration of my employment mentioned above. (I didn't want to risk them "owning" it because I worked on it while in their employ.)

Nevertheless, the server has been continuously running for at least 5-6 years now (probably closer to 7 years) with a very few active users. Most of the potential users (who are already familiar with the CONNECT interface) use a CMC at RPI called "lily", a successor to "Clover", which was a successor to CONNECT. (RPI has a long CMC history!) Phoenix is intended to be a community-building system, and establishing a community is a chicken-and-egg problem. Similarly, finding time and motivation to improve the system is harder when there's nobody to benefit! (Yet I have a TODO list a mile long!)

Okay, so the obvious question -- why haven't I released the code? There are several reasons, though I'm not sure how good they are. One was pragmatic -- I wanted to build a userbase for the system, and releasing the code before establishing a userbase would risk having someone else take my code and get the users by virtue of finding more time to work on the features they wanted. (The obvious alternative is to seek a different community of users to attract, which probably involves a new UI.)

Another reason was that I always wondered if the code could potentially serve as the basis for a commercial product of some sort, with the goal of making me enough money to live on so that I could spend my days programming free software as I'd prefer. (Maybe that's not the best way to achieve that goal?) It's part of that classic question of "how do you make a living while writing free software?" (I'm still not sure about this one.)

Another reason is that I never felt the code was quite "ready" to be released. From the user perspective, many of the basic features in the "competing" systems were still missing, although they weren't necessarily hard to add. More importantly, I still had some core architectural changes in mind, which I wanted to accomplish before exposing other developers to some of the ugliness in the existing code. Equally important, I wanted the code to be a good demonstration of my coding skills, and not all of the design or code meets my personal standards for such a use.

I suppose I'd still like to be able to release the code, but I'm still not sure I'm ready to do it yet. At the very least, I'd like to reach a clean "stopping point" with the code first. Sure, I could release it today, but I think some things really need to be cleaned up first, some core features added, and some architectural changes made. Then I could see releasing it. (I'm still a little wary of the possibility of forfeiting any monetary potential it might have; any thoughts on that?)

If anyone has bothered to read this far, who is interested in trying the system as a user, send me email at deven@ties.org and I'll tell you how to get signed in and look around... (If you haven't read this far, then nevermind! :-)


New Advogato Features

New HTML Parser: The long-awaited libxml2 based HTML parser code is live. It needs further work but already handles most markup better than the original parser.

Keep up with the latest Advogato features by reading the Advogato status blog.

If you're a C programmer with some spare time, take a look at the mod_virgule project page and help us with one of the tasks on the ToDo list!