Older blog entries for maelstorm (starting at number 9)

Have a basic version of Object working until toad and I flesh out the view/filter hierarchy. Shouldn't be too bad, it's just a little repetitive.

I also finished a caching mixin for all the Data subclasses. It will basicly memoize any search result in a (presumably) faster cache collection class. As long as the cost of lookup in the cache is lower then the cost to look things up in the the collection that is using the cache mixin, it's a win in time, if not space. At least the cache stores thing in strong references right now, rather then having a second copy of the data.

Life/Work/Everything

3 days till I fly to London. Hopefully, what I'm current suffering from is allergies, and not a cold. At any rate, I'm gonna need to stock up on decongestants, or risk rupturing one of my eardrums again.

Don't feel entirely prepared -- my slack coefficient at work is rather high, so the ratio of work completed/work that needs to be finished is slowly approaching zero. Blah. Need to finish documenting/exporting the db schema so I can load it up on the host machine once I get there. Worst thing is that we won't have a machine to install things on until midweek. Delays in shipping, I guess.

My stepdaughter is beginning to pull out of her depressive slump. And I seem to be reaching a new level of acceptance. She asked if she could call me 'dad' the other day. That felt good.

Putting this here until I update the coldstore task list on sourceforge.

These are tasks for adding a view/filter class hierarchy for coldstore. I feel a little like we're re-writing STL's tricks with iterators. Most of the items that have the Or suffix are actually filters, not full fledge sets.

• OrSet. ObjectSet : public OrSet, adds pointer back to its real object, makes mutable.
• Object: Namespace, automatically allocates an ObjectSet. Implements parents() but not children().
• Caching<> - for Caching<OrSet>.
• Weak<> - when an object is turned into a Dead (requires VP rewriting :)), it is removed lazily by weak sets.
• InheritanceSet : public Weak<Caching<OrSet>> - adds (limited) tree traversing deletion propagation.
  Takes an htl parameter, stops when has removed all occurances or has looked at more than htl Objects. Has a list of children, so we can implement object::children() at this point.
• ImpureInheritanceSet - adds a private set, of things that will be looked up but not inherited. ObjectSet now more or less full featured.
• mutability - Colin VP rewriting allows run time switch mutable-cow. Not strictly needed, as can just force it in ObjectSet, but... Requires implementation of transparent redirects in Slot, which means we can do POrSet, once we have the other stuff needed for it

Starting to ponder strategies for increasing general awareness for our company, in hopes to drum up more business for us. I was starting to think that writing short articles about whichever technology we're currently working on might help show that we are competent.

We're working with alot of stuff that people would think was at least somewhat interesting, and/or useful -- using XML/XSLT/ASP/JSP/Java/WebObject/etc... Posting postmortums and task strategies would help us as well. We would have a record of how we approached the problem solving aspects of a given project, and see where we have room to improve.

Ideas, anyone?

Coldstore is moving along nicely. I've finished the initial hooks from libiberty's demangler to our interning library.

opiate has added a partial language binding for persisting Python, and has also begun the process of preparing the interface for callouts to Java code. Nothing in it yet to reverse things. I'll have to take a look at it.

I feel my C++ skills have majorly atrophied. I really haven't used it seriously as a programming language in over 2 years, and so things are coming a little rustily to me.

I think I'm going to add a prefix notation interpreter to start testing our vm nodes this weekend. While it's not strictly required, it would be semi-orthognal to our postfix notation interpreter (chaos).

I also have to finish up work on my Object class, second pass. One of the other developers has an efficient implementation of namespaces that I'm going to derive our objects from. For now. He and I fleshed out some ideas for using mixins on one of the classes closer to our base class.

My passport should be arriving tomorrow. My itnerary is set. I should be in London in a little over a week, for approximately a week. Should be exciting, even if I do have to work through most of it.

Life

Suffering greatly. Trying to get my house ready for market, so I spent the weekend cleaning it. Apparently, we stirred up enough dust to trigger a rather severe allergy attack, so I'm looped out today, and mostly useless.

Work

Looks like I've got three projects that are going to be dumped on me simutaniously. Not necessarily looking forward to that. I'm also in the process of procuring an expidited passport, because they need me to fly to London to provide technical assistance for the final handoff of the project that I've been managing. Should be fun.

Looks like colin has managed to fix our python support to something approaching usefulness. Variable bindings are preserved, and we can handle a few of the base python classes. opiate is working on extending the support to user defined classes right now, but is bottlenecked by some of the code that I'm working on that represents Objects with member variables/functions. Should be interesting.

Project status

Looks like I'm going to get a little time to work on coldstore during the weekend. If nothing else, I'm going to have to review opiate's work, because his Python binding to the store is finally working for initial population of the store, but not for subsiquent loads of the store.

Work

Blah. Finishing up the last of some reports for site usage for out of our clients websites. I hate writing reports. It did get me to do some nice refactoring, though, to clean up our reporting class library. Changed the Report generation class to an interface, instead of being solely for PDF based reports. Modified some other stuff to make it not rely on absolute file paths, but rather the class path (with the absolute path as a fallback if the resource load fails).

It sounds like we're going to get some more time to pull a better class library out of the codebase after we do our last bits of wrap-up. Which is good. I hate having to re- invent the wheel. Maybe I can convince them to use tapestry for the next project, though it looks like we're going pretty purely over to XSLT and XML for our next projects.

bruce: What are you guys doing with Cubik? I thought TOM had become abandonware...

neale: Yes, colin worked on coldmud a long time ago. We still have some of the old sources lying about, as well as a couple of experimental cores. You wouldn't happen to be the same neale who was on the cold dark/genesis mud?

Coldstore was seeded by Colin's desire to have something that would work very well as a testbed for experimenting with both document storage and the collaboration that we've grown to love on various user programmable muds. But I suppose that's what most of the newer text based muds are for these days.

The developers of coldstore tend to hang out on Xao MOO, whose primary focus has become talking about development of coldstore, and various interesting bits of political and philosophical rhetoric and debate. Please stop by. It's a fun time, and an excellent place to get real time feedback if you're stuck on a programming problem at your $job. Or even if you're not.

nzkoz: Try compiling with -Weffc++ if you use gcc as your compiler -- it provides warnings during compile time for code patterns that are thought to be bad in the text of Effective C++

<Gripes/Feature requests for Advogato>

There seems there are a few parts of the process of community building that Advogato has missed in its attempt to foster a strong community of developers. First, it seems that despite an observer level user being able to create a project, there's no way for another observer working on that project to note that they are, indeed, part of their project. Because of that, the project I'm working on, Coldstore, now has two project pages: here and here.

I suppose part of it is case insensitivity in project names, which is ok. But the other issue is that we can't add each other to the same project.

Second issue: When users certify you, it would help if they could attach a comment that was reviewable by the user for why they chose the level of qualification of the user. Why? Since we're trying to build a community of qualified peers that can help us with well envisioned and rational critism for our ideas, it would be helpful for those who are deemed only observers or apprentices to know what our peers think needs to be improved.

</Gripes/Feature requests for Advogato>

Peeve of the day: Java doesn't provide an easy way (or even a one off) of introspecting into any publicly exported classes to find out whats there at runtime.

I suppose the reason for this is that it might be seen as a potential security violation. After all, your program should know exactly what it's dealing with.

The task I wanted to accomplish was the automatic detection of all implementers of a certain interface for report generation at runtime in order to build a composite report and another for finding all batchable tasks in the jar. There are other, more specific ways of doing this, that also require more code management -- I could add a static set of calls in the class declaration of the various implimentors that automaticly registered the class with some singleton management class. I could use a property file with a list of class names of reports that I wanted to generate (or tasks that I wanted to have run). It was suggested that if I knew the jar file name, I could also suck out the class names from the Manifest (haven't looked into that option yet).

Any other suggestions?

Spent my evening after work playing with Coldstore's Chaos language. While it already works, it's all direct interpretation, and only minimal error checking for stack depth requirements. So I spent the evening extending the primatives list to include stack information.

Next will be some decisions on how to do bytecode representation, and a seperate version of the lexer that emits the bytecode, rather then direct interpretation.

Looked at a RPN based functional language called Joy -- there's definitely some interesting concepts that could be borrowed from it, and it's one of the reasons for adding the stack effects notation to the current set of primative operations. I think in a later iteration, I'll try to use that to guess 'correctness' of procedures and stacks.

And spotted a scary thing on comp.lang.functional: Scheme implemented in JavaScript.

I've been spending the past few weeks trying to understand functional programming, especially OCaml. From what I've read, it's supposed to be one of the fastest functional programming language implementations (and corrispondingly, one of the fastest ML implementations) out there.

It took a few years for it to start to crystalize for me. I think I first started looking at SML around 1996, and tried to convince, without success, one of my Math/Com Sci instructors to assist me in a independent study exploration of it. His reasoning was that: 'At this point in your degree, you should be able to pick up any programming language'.

I guess the only thing he really didn't count on is that ML requires a different mindset then the imperitive programming languages that were pretty much the standard. I had taken some LISP with him, but the approach there was limited to symbolic manipulation for simple AI stuff, like eliza, deeply recursive functions, and information space searching.

Thats all well and good, but it still didn't prepare me for actually having to worry about domain mapping, and something so well and thoroughly steeped in the lambda calculus, and side effect free coding.

But it's finally making sense. I kinda wish I had a project to use it on.

The big reason I'm looking into functional programming right now is that I'm hoping to figure out some of the nifty implicit typing rules for Coldstore's second programming language, freon.