Apr 93 Editorial
Volume Number: 9
Issue Number: 4
Column Tag: The Editor's Page
MADA Conference Who, Where and What
By Neil Ticktin, Editor-in-Chief
For those of you who don’t know, MADA is the MacApp Developers Association.
Today, that is a bit of a misnomer - they are beginning to take on more than MacApp.
For years, MADA has been touting (along with Apple) the benefits of object-oriented
programming (OOP). If you haven’t at least heard of OOP by now, you’ve probably
been hiding out in Northern Greenland waiting for the ice to melt.
For the past several years, MADA has held their annual MADACON conference.
This year, the conference was held in San Diego, February 15-19 and had a few
fireworks to go with it. Here’s some of the happenings
SK8ing
There were a few very impressive things shown at MADACON. Kurt Schmucker
from Apple’s Advanced Technology Group (ATG) gave the keynote on OODL Authoring
Environments. The heart of his talk was about a technology nicknamed “SK8”.
First, I should make clear to you that they were not announcing product, just
showing off a technology. For a while now, we’ve all been saying that ultimately
computers need to be programmable by non-programmers. When Bill Atkinson first
came out with HyperCard, his vision was to have a ‘software erector set’. HyperCard
was a start, but ‘serious’ developers never took it seriously.
It is clear that at this time, the software development market has a rich set of
70’s and 80’s tools, but a breakthrough is needed. ATG’s task was to combine the ease
of HyperCard with the power of MacApp. ATG had a few goals: leverage developer’s
time, dramatically increase the developer base, and create the ability to develop for
different platforms as well as different metaphors.
ATG soon realized that more dynamic languages (such as Dylan) were the better
route. But, Dylan is not for everyone - they needed Object Oriented Development
Languages (OODLs) for the masses. Their result: Object Oriented Dynamic Authoring
Languages - OODALs for short. The key here is to “empower subject matter experts to
create content with less dependence on programmers”.
The result of all this research is a powerful OODL Scripting Language with
powerful graphics, direct manipulation user interface, and knowledge representation,
inferencing, and constraint solvers. In other words SK8.
So what are the specifics? SK8 is built on top of Macintosh Common Lisp ( which
says a lot for MCL). A language called SK8Script is built on top of a group of systems -
objects, events, 2D graphics, OO rules, and constraints. A set of core objects are then
built in SK8Script. SK8Script and this set of core objects are what the “author”
interacts with.
SK8Script has greater expressive power than HyperTalk, is simpler than
HyperTalk, has all the power of MCL or Dylan, but is incredibly easy to read and write.
There isn’t room for a lot of examples here, but let’s look at one. Let’s say that you
want to remove all the bold words in a document. To do that you would write:
Remove every word whose style is "bold" in the document named "foo
Pretty simple stuff, but it’s powerful.
SK8 can be used in high-end multimedia authoring, vertical tools generation
(i.e., online training systems and documentation systems). Today, SK8 is being used in
conjunction with people at Boeing to develop a training system.
What does this mean to you? ATG has been teased for only working on
technologies, but not actually shipping product. They are aiming to get some (or all)
of the concepts worked into development platforms. Some people have termed SK8 as
“HyperCard on steroids”. Hopefully, the HyperCard team (e specially now that Apple
has control of it again) will embrace some of SK8’s concepts and integrate them into
the next version of HyperCard.
Little by little, Symantec and Apple are letting out information about Bedrock.
Some people think that the Bedrock team is holding back on information because it
doesn’t know a lot of answers yet. Even if this is the case, it is true that the Bedrock
team (BT) is making progress.
At MADACON, the BT let us in on some specifics. Bedrock is an application
framework, not just a GUI class library. It will be easier to use than the native API
and is platform independent.
As of MADACON, Bedrock had almost 400 pre-tested classes and the quantity is
continuing to grow. File handling will be platform independent and will take on the
native look of the platform you are running on. Strings will be supported through
ANSI string classes, validators (time, date, numerical), and formatters (for date,
time, and currency).
The BT announced that they have licensed a subset of Rational’s Booch components
(maps, stacks, queues, etc). This is great because Booch is a noted industry
standard. Their tools are second generation and they therefore know a lot more than
most on the market. As a result, the Booch components are flexible and complete.
The design philosophy behind the data structures is seemingly well thought out.
They are template based with mixin inheritance, exceptions, public inheritance for
interface, and private inheritance for implementation. Bedrock will provide tools for
sequential and binary searches, QuickSorts, and storage allocators.
Jim Lloyd took a moment to discuss exception handling and why they took that
path. Exceptions are a good error handling methodology, and furthermore, allow for
the use of multiple independent libraries (e.g., Booch). The BT’s goal was to adhere as
closely as possible to the Annotated Reference Manual (ARM) definition. They wanted
to translate platform-specific errors into platform-independent exceptions and
provide built-in testability. Bedrock will allow you to see a log of wherever
exceptions could be thrown and gives you the ability to identify what to handle. The
error handler uses a significant subset of ARM and has automatic clean up of stack
objects. Exceptions can be thrown from constructors. Exception types are classes
which are organized into a type hierarchy. Bedrock’s take advantage of the “ resource
acquisition is initialization” idiom. The exception hierarchy will have about 60
different classes that are defined into BEL (the Bedrock Exception Library). There
will be sample code to demonstrate BEL.
Mike Burbridge discussed Bedrock’s memory handling scheme. Mike said that the
design goals and criteria was for: an average block size of 50-500 bytes, large request
stream (10,000 blocks), 85% space utilization, time efficient, and transparent to the
programmer. To reach their goals, they used a “best fit” allocation strategy, free-list
stored in a binary tree, and made modifications for small blocks (<20 bytes) to reduce
overhead per block. The good news is that they’ve come up with a strategy that works
fairly quickly (they showed test results to prove this).
Bedrock will have a platform independent resource language called BEDRC. This
compiler will work similar to Rez and will produce a platform specific binary file. It
supports views, menus, string lists, bitmaps, cursors, icons as well as user defined
types. Data types can be inherited and can have recursive definitions. BEDRC has a
full ANSI C preprocessor and will parse C++ header files so that it can go into classes
and get constants. The compiler supports a mechanism for native resource definitions
and can use the #pragma command. There is a resource editor under development.
According to Steve Levine, Bedrock product manager, they will have a developers’
release in May at WWDC. This will include demo code/technical information and may
be limited to a select group. They will beta the product in Q393 and ship in Q493.
MacApp -> Bedrock
If it wasn’t clear to you already, Apple and Symantec are not going to be able to
provide a complete auto conversion for your code already using MacApp. To do that
would have been as big a project as Bedrock itself. Instead, the Bedrock Team will
provide tools to help. For example, there will be a tool to convert all view resources,
but it won’t convert custom resources. They will have a utility, called Witches Brew,
which will analyze an application’s source files and mix in MacApp 3 headers. The
utility will create a text file containing MPW commands indicating the change that
should be made in your code. You will still have to do the actual editing though. The
team has taken the safe approach and will only be making changes automatically if
there is absolutely no doubt in the translation (e.g., resources).
Last year, Apple showed off Newton a bit at CES. This time, they did it again. For
those of you who are still skeptical, we saw them demonstrate a Newton. Yes, they used
a stylus, wrote in script (not block printing) and it recognized the letters converting
them to computer readable text. This thing is quite cool and it does work!
James Joaquin, Product Marketing Manager for Newton Core Software and Tools,
led most of the talk. His first point was that Newton is not a small Macintosh, it is an
entirely new metaphor. Newton aims to help people do what they do everyday -
information capture, organize, and communicate. To capture, Newton allows users to
enter in free-form text and graphics. Organization is covered by the address book,
calendar and other applications. Newton communicates by allowing a user to print,
fax, and transfer data to another Newton or to a desktop machine.
The Newton team is interested in developers producing 3rd party add-ons and
software as well as having them as “early adopters”. There will be a wide range of
tools over time and it will be an open platform where “anyone can play”. This is a new
category with new applications and opportunities.
Newton’s information architecture is designed for object-oriented data storage
optimized for storing, finding and linking small pieces of information. This structure
is so ingrained into the machine that developers will have to use it. The architecture is
based on the frames technology - it is out of the AI world, but it is not a full blown
knowledge system. They’ve included a number of standard data types to enable
information transfer across applications.
For those who already use MacApp, you’ll be happy to know that Newton’s
hierarchical view system is similar to MacApp’s but built directly into the system.
There are a lot of views already built in, ready to use. The architecture is quite rich
and is extensible by developers.
To develop for Newton, initially, you will use a Macintosh. Eventually, there
will be tools for developing directly on Newton. Expect good communication paths
between PCs/Macs and Newton. Apple will be talking a lot more at WWDC ’93 in May.
In the interim, you can contact Newton Developer relations on AppleLink at
NEWTON.DEVS.
Windows development and other talks
There were a few sessions on Windows development. Emergent Behavior spoke
about porting your MacApp project to Windows. The main thrust here was to keep
your user interface code separate so that it could be more easily rewritten.
Microsoft is continuing to try to make a splash in the Macintosh development
arena. They are showing off products such as Object Linking and Embedding (OLE) and
Microsoft Foundation Classes (MFC). They are trying to convince Macintosh
developers to write for Windows, but to me, it still seems like the fox preaching to the
hens in the hen house.
There were the typical talks on MacApp tips, C++, object oriented programming,
etc Solution-Based Modeling (SBM) got a warm reception from the audience and,
Apple spoke about Dylan some more.
Things have been kind of quiet in the Taligent camp. They’ve been not only
working on the project, but also moving and getting more people on board. Taligent has
been looking at long term trends in computing. Since the 1960’s, systems people have
been progressively moving the code common to applications into the OS, GUI, and into
frameworks. Today, developing has become so complex that there are basically only
enhancements to existing products and no new innovation.
The people at Taligent are trying to change the way development works. The idea
is to bring the process back to the time that a small developer can build something.
This is good not only for the small developer, but for larger ones as well. Their
answer is to integrate tools into the OS and then let people approach it in a holistic
manner. There aren’t many details - they are saying that they will ship something in
the middle of this decade. Stay tuned
Products shown
Shows like this always have a lot of products displayed. There is definitely not
enough room here to do justice to these products, but here are a few that were shown:
SmallTalkAgents™ - an excellent development environment for Macintosh SmallTalk
developers (due out in the next couple months), Component Software’s Component
Workshop, Serius Developer, BETA (now being published by MADA), ObjectModeler™
- a design tool, OOPC - a MacApp alternative, Camelot and Quorum - cross development
solutions, SBM tools for more effective development solutions, Ad Lib - a ViewEdit
replacement, VisualWorks - a SmallTalk Application Development Environment,
NeoAccess - an OO database tool, IcePick - a MacApp View editor, First Priority - OO
prioritization tools, POET - a cross platform OODBMS, and more
MADACON as a whole
There was a whole lot more that happened at MADACON - talks on managing large
OO projects, how to port MacApp project to Windows, OOP directions - not to mention
the excursion to SeaWorld and the reception following. All in all, it was a good solid
conference showing off some interesting technologies and providing a platform for
discussing the future of Mac development.
Neil Ticktin, Editor-in-Chief
The Publisher's Column 
Hardware upgrades versus replacements
By David Williams, Publisher
So, last column, I asked questions about Apple’s new model-turnover strategy.
No sooner had that coloumn gone to press, when Apple announced a whole new list of
models, prices, and features. To make matters personally worse, MacWeek noted that a
Quadra 800 has more bays and is actually slightly faster than my shiny new 950,
which was marked down in price from when I bought it. Yet, the software that really
makes these little boxes useful remains largely unchanged. Why is it that it’s
acceptable for upgrade hardware to be brought out at full price, with a few exceptions,
while new software is almost always priced very cheaply for upgrading? What does
this difference mean?
To me, the main impact of this disparate pricing structure is that there isn’t as
much incentive to develop new software as new hardware, since new hardware
generates new revenue while new software doesn’t. The relative slowness of software
development can probably be tied back to the fact that there isn’t the big immediate
payback of lots of full price sales.
I wonder if software producers couldn’t learn a lesson here? What if developers
brought out software designated comparably to hardware, so there would be, for
example, QuickMail 950, which would be promptly replaced by QuickMail 800, at full
price, of course. The hardware manufacturers don’t seem to mind that their model
numbers don’t stay linear compared to performance, so maybe software producers
shouldn’t either.
The standard answer to all this is, of course, that hardware is more easily
differentiated by the buying public than versions of software. So the hardware guys
can get away with introducing a new model every six months while software guys can’t.
I wonder if this will still be true when the “new” models aren’t technologically much
different than the old. The new Centris machines make justifying a Quadra very
difficult for business purchasers. Yes, there are little differences that mean things to
“computer-types”, but there aren’t the big differences that the average business
buyer, like me, can really latch onto and parade before the board of directors.
It’s an interesting question being posed by Apple, e specially when
“upgradeability” is the new watchword in PC design. Intel worked hard to be able to
sell aftermarket customers an easy-to-install upgrade chip instead of a new box. It
appears to me that the old lesson the software industry learned about upgrades versus
replacements has now been learned by Intel, and forgotten by Apple.