Older blog entries for taj (starting at number 1)

Getting to grips with weblogic server and process integrator, now that our week of slee..er, training is done. It's amazing how quickly my snooze button gets toggled as soon as I sit down in anything remotely resembling a classroom.

Weblogic seems like THE implementation for J2EE. Normally a lot of this "enterprise" software is designed to look good to the people who fork out the cash, ie managers and executives. Weblogic OTOH seems to be designed for the guys in the trenches, like us programmers. I guess I'll only find out what it's really like once I finish a few projects with it, but for the time I'm enjoying learning and using WLS and Process Integrator (another fantastic bit of software, especially if you've tried to implement your own workflow engine in the past).

Good job BEA, and congratulations to whichever company/companies you bought out to acquire this stuff. Dropping the word "Tuxedo" into any chat about your other products is also a great way to remind us that you stake your reputation as a big iron vendor when you sell stuff like weblogic. There's too much half-arsed software out there and I'm surprised and impressed that you put behind your software the reputation you've gained from Tuxedo.

Meanwhile, KDOC is humming along, especially now with the Netwinder set up in the living room! I've been waiting for this Divan Programming Environment for quite some time.

Now that the parser seems to be complete I'm working on the design for the new scoping and tree searching engine. The old model was never going to be enough to handle namespaces and heavily templated code.

It looks like template specializations are still going to prove to be a problem. Preliminary analysis (ie napkin math) suggest that a full-blown implementation of this stuff is going to hit performance quite a bit, apart from being hard to do without spending more time taking the types of the template args to bits. Oh well, one problem at a time...

Next step after that is a major restructuring of the HTML output. It is functional right now but it can be so much better. CSS comes to mind first.

Started swimming again, this is good. It's been too long. Body lethargic == mind slow.

Well I've been reading some diaries on here lately and was thinking of writing one for myself eventually, so this is as good a place to start as any. Let's go:

I've had a chance go get KDOC back to a working state again, one of the very few saving graces of not having Nicole (nicnacs) here with me.

There are few joys like a huge lump of code that compiles and runs the first time. KDOC compiles C++ a lot better now, and I'm amazed at the speed. It's noticeably quicker with the giant regexps I wrote and the

(?>..)

construct that perl offers. I guess this means my old parser and regexps were horrible and that perl's regexp engine is very quick indeed.

Much as I like perl, I'm having second thoughts about using it as a language for anything over a few KLOC in code size. In projects of respectable size, clarity and documentability matter more than the clever tricks you can use.

KDOC is now roughly 6000 loc, and while it tends to get smaller every now and then as I refactor bits, not having something like KDOC for KDOC doesn't allow me to see the "big picture" the way generating docs for a C++ or java does. One thing that really bothers me is my inability to find myself a coding style that doesn't go out the window whenever I learn a new perl feature (eg I just started using ($,..) in subroutine declarations).

Most one-night hacks tend to grow as time goes on, so I think I will choose python for my next castles-in-the-sky project.

A lot of people think I'm misusing perl when I generate regexps like the one below. I guess I'm just glad I don't have to do it manually.

This one matches a method/function declaration.

(?:((?:(?:(?:(?:(?:(?:(?:(?>\:\:)|(?:[_\w~]+))+)|
(?:\s*(?:<(?:(?>(?:(?>[^<>]+)|<[^<>]*>)*)|<(?:(?>[^<>]+)|
<[^<>]*>)*?>)*?>)))+)[*&]*)(?:\s+(?:[*&]+|
(?:(?:(?:(?:(?:(?>\:\:)|(?:[_\w~]+))+)|
(?:\s*(?:<(?:(?>(?:(?>[^<>]+)|<[^<>]*>)*)|<(?:(?>[^<>]+)|
<[^<>]*>)*?>)*?>)))+)[*&]*)))*)\s+[*&]*)?)
((?:(?:(?>(?:(?:(?:(?:(?>\:\:)|(?:[_\w~]+))+)|
(?:\s*(?:<(?:(?>(?:(?>[^<>]+)|<[^<>]*>)*)|
<(?:(?>[^<>]+)|<[^<>]*>)*?>)*?>)))+))\s*
(?:(?:\[[^\[\]]*\])(?:\s*(?:\[[^\[\]]*\]))*)?)|
(?:operator\s*(?:(?:\(\s*\))|(?>[^\(\)]+)))))\s*
\(((?:(?>[^\(\)]+)|\([^\(\)]*\))*?)\)\s*((?>const)?)
\s*((?>=\s*0)?)\s*(?::[^{;]+)?)