🚀 go-pugleaf

Ramon, et al.
 
> My vision of this project is more along the lines of a blend between a
> conventional compiled language and an interpreted language. It seems that
> many of the promises of OOP fall apart when forced into a conventional C (or
> Pascal or what have you) development environment.
 
> ...  more perfectly correct complaints about OO development today
 
 
My, what a timely link. I just got back from spending the last three days
working with has the potential to be the most wickedly cool development
environment I have seen in some time. It is specifically geared to address the
problems you talk about, as well as a number of others.
 
I like to be careful when it comes to new environments, but after seeing this
environment I feel like I just saw the Mac for the first time, in 1983.  This
is very cool stuff.
 
The environment is Component Workshop (CW). It is delivering today what Dylan
is promising for the future, and the future is going to be fun. Long compiles
are killed off by an incremental compiler/linker. Applications can be debugged
_and modified_ as they are running: you never leave the environment you are
writing the code in. As a matter of fact, you can directly modify the
environment itself, if you so choose. On the fly. And see the results
immediately.
 
CW is not a traditional environment being used for OOP, like MPW, Think C,
Borland C++, or their ilk. It is a true object oriented environment, where the
code and classes you are defining are themselves objects, and can be addressed
as such. (For example: I had to add a data member to a couple of dozen classes.
I just wrote some code that asked the classes to add the data member, ran it,
and the members were there. And the environment went out and changed the
running instances of those classes for me, on the fly, so that I did not have
to restart). At first, I thought this was just a small difference, but it
isn't; it is a completely different way of looking at software development.
 
CW also takes care of memory management, so I don't have to worry about
instance deletion. I just keep references to an object around as long as
needed, and once the references go away, the object does as well. (No more
early deletion, or memory leaks).
 
CW is C++ based (more or less), so that I don't have to learn a new language. I
say more or less, because there are differences between CW C++ and USL C++, so
code will not directly port over. But at least I don't have to learn a new
syntax. There is a lot of differences in the way C++ is used than we are used
to (a heavy dependence on the envelope/letter metaphor, for example), but a lot
of that can be ignored if you don't care about details.
 
CW does have a framework built in, and they claim it will be ported to Windows
soon. We'll see. Right now, it is not as strong a framework as MacApp, but they
seem to realize that this end of the product needs to be strengthed, and are
working on it. Not that the framework is bad, just that it is not as feature
laden as MacApp. Some of our favorite MacApp features can be added quickly, I
think, so I remain optimistic. (I added Behaviors, for example, in about 8
hours. Again, the applications I already had around got Behaviors instantly,
without having to be rebuilt. Wicked).
 
The other piece of CW that is currently weak are the support tools,
specifically in the area of view editors. I do know this is being worked on,
but I don't know if I can talk about that...
 
Like Dylan, CW promises to be able to remove the finished application from the
environment, so you don't have to carry around the 16M of environment. They are
claiming MacApp-like sizes for stand-alone applications, circa 350K for a
nothing application. This is heresay as far as I am concerned at this point,
because I did not actually get a chance to test the extruder (as they call the
piece that does this). However, these are sharp people, and I have no real
reason do doubt that they will come in somewhere around that. If you are
waiting for Dylan, and especially if you are waiting for Dylan and are leery of
that Lispy syntax, you owe it to yourself to look at CW.
 
One last point: in CW, you can have that nothing application up and running,
with a full Mac interface, from scratch, in about a minute.
 
So: At this point, without seeing or playing with Bedrock, I would probably
start new cross-platform projects in CW, and new Mac specific projects in
MacApp. It would be hard, though; going back to MPW at this point is going to
be a painful experience. If CW can deliver on their promise of MacApp like
functionality, then I would use CW for everything.
 
Until, of course, something better comes along ;-)
 
 
Bob
 
 
 
Bob Hablutzel
Hablutzel Consulting
ALink: B.HABLUTZEL
Phone: 708 328 0130