Category Archives: News

Temporary Objects

One of the final hurdles in designing a BOOL implementation involves temporary objects. Any operation on an object may result in a transitory new object that is consumed by later operations. For example, in the arithmetic expression “5 x (3 + 4)” the addition operation creates a transitory value — 7 — required by the multiply operation.

The question for an implementation is, “Where to store such temporary objects?” In some languages, CPU registers suffice to store transient values (such as seven), but in object-oriented languages, registers aren’t enough. Objects take up some space, and often temporary objects need to be addressable.

Continue reading →

Advertisements

Message Arity (revisited)

I recently determined to use a trailing marker — a semicolon — to close the list of arguments due a Message. But after using it for a while, I’ve decided that this:

.   set:x add: mul:a b; div:c d; ;;

Is butt-ugly and has to change. Since I still think registering Message arity is an even worse option, I’ve had to take the only other real option: assuming Message arity.

Continue reading →

It’s Alive! (Sort of)

There was meant to be a third article in the Native Objects series that would discuss the Actions (“methods”) supported by the native Models (“classes”). But I’ve only begun to define those things. For now, suffice to say that typical data types (integers, floats, strings, etc.) have the methods you’d expect. Assignment for all, basic math for the numeric types, stringy stuff for the string; you get the idea.

I’ve reached another major milestone, but I’m also about to begin another design phase as I figure out exactly how to implement the native Models. And I may be taking a break from this blog to give BOOL a rest and to deal more with other matters.

Continue reading →

Arrays, Final(ly)

I think the final piece of the array puzzle finally fell into place. The issue resolved when I last wrote about arrays — whether all data Models have array capability versus arrays being a distinct data model — still stands.

The final piece involves a slight syntax change and — much more importantly — the full rationale for the array syntax. Not really having one was a bother; it made arrays seem arbitrary and patched on. The rationale brings them more fully into the BOOL fold.

Continue reading →

System Messages

From the beginning BOOL had this concept of System Messages, but they’ve never worked out — even as a design idea. Now that I’m working on the first realistic BOOL implementation, it’s even more clear the idea isn’t up to the reality.

System Messages —  at least as an orthogonal idea — are dead. The few that are fundamental to BOOL still remain. Two of the more important ones are the Query Message (q:) and the Execute Message (x:).

Continue reading →

Gated Lists (update)

I’ve changed my mind about the Gated List syntax. (These mind-changes are a key reason BOOL design is endless!) The idea of binding a label to the first statement in a List to indicate a Gated List just didn’t make good sense to me.

The problem is two-fold: Firstly, a key reason for Gated Lists in the first place is their use as named Action clauses. When the label is buried in the List (because it now belongs to the first List member), there’s no sensible way to migrate the label to the List. Secondly, a label on the gate expression really makes no sense and has no value.

So I’ve come up with something new!

Continue reading →

Message Arity

There is another long-standing knotty BOOL issue that I’ve recently resolved. It has to do with the arity of functions. The original syntax of BOOL assumes the compiler knows how many arguments go along with any given Message. There is always at least one argument, the target object of the Message.

The problem is that how many other objects are involved depends on the the Message. For example, an add: Message has its target and one other object (as do nearly all math, relational and logical operators). But some Messages, sqrt: for example, only have their target.

The compiler needs to know this to build the Message properly!

Continue reading →

BOOL Reference Implementation

I’m once again having a go at creating a BOOL Reference Implementation. I’ve tried this in code nearly half a dozen times before, and I’ve doodled countless lines of pseudo-code over the years, but I’ve always gotten bogged down in details and unknowns before.

Continue reading →

Gated Lists

I think I just solved a long-open issue in BOOL regarding conditional Lists. It’s something that’s been nagging me a long time. For one thing, it’s one place that’s line-sensitive, and BOOL tries to avoid that. (Actually BOOL is very line-sensitive, but not that way.)

The other thing is that it conflated two things into one, and that’s also to be avoided. Clarity is everything, and not overloading concepts is an important part of clarity. (Orthogonality is another clarity goal that BOOL considers important.)

The background for this goes back to a BOOL primary design goal and technique.

Continue reading →

In Disarray

One of the things that’s kept me from completing BOOL is that I haven’t been able to make up my mind regarding arrays.

There are two basic directions: All data types can have the native ability to create single or array instances, or the Array type is a special data type that can make an array instance of any data type.

There is also the issue of what should be the array syntax. How are arrays declared, and how are array members referenced?

I think, after all this time, I have finally made up my mind.

Continue reading →