The primary theme of this year's conference was the future. Although there were exceptions, much of what we saw were forthcoming technologies or newly available technologies that haven't proven themselves yet. In fact, one of the two major running jokes of the week was "This is not a product announcement." A number of people came to the conference looking for a new framework and/or development system. Most left not fully satisfied, though many are planning to try Component Workshop™.
The headliner of the day was the Bedrock team who said more than they've ever said before and less than most people would have liked. It was made clear that we haven't seen a complete class hierarchy because the class hierarchy is still changing. As expected, this also was not a product announcement. Lonnie Millett presented Bedrock as three components, the application framework, support classes, and the resources. The application framework will be much like MacApp 3 with a number of familiar kinds of classes. It will have a view hierarchy and a command hierarchy similar to MacApp's. The Bedrock support classes come in 6 types: memory management (its own pointer-based allocation), exception handling, files (similar to TFile), string classes (ANSI, Pascal, and unicode), data structures (lists, etc.), and international facilities (including validators-date, time, numerical-and formatters-date, time, currency).
The team went on to add some detail on four pieces of Bedrock. The first of these was the data structures. Bedrock will use a subset of the Booch Components. These collection classes are template-based, use mixin inheritance, and throw exceptions. The classes with Bedrock will include collections, sorted collections, sets, queues, stacks, maps, and a binary tree. Tools provided will include sequential and binary searching and a quicksort.
The second item to be presented was exception handling, which will be ARM compliant, will handle automatic cleanup of stack objects, and will allow exceptions to be thrown from constructors. The exception types are classes, organized into a type hierarchy. Bedrock will come with 60 defined exception types. The current exception-handling scheme uses macros to duplicate the ARM functionality and once native compiler support for exception handling is available, very few changes will have to be made to take advantage of it.
The third subject was the memory allocation system which is designed to handle the small average block sizes and large request stream of the typical object-oriented program. The implementation approach chosen is a best fit algorithm with the free-list stored in a binary tree and some modification for very small blocks. The team presented a performance analysis which showed the Macintosh memory manager falling flat on its face and their algorithm doing fairly well in both space utilization and speed.
Finally, the team talked about the Bedrock resources. Bedrock resources will be defined in a platform independent resource language similar to Rez which will support inheritance and recursive resource definition. Available resource types will include views, menus, string lists, bitmaps, and icons. User-defined types will be possible. The resource compiler will use a full ANSI C preprocessor and will parse C++ header files. A resource editor is under development.
The Bedrock demo took a while, as Bernadette Jolicoeur attempted to copy source files from a Macintosh onto an MS-DOS floppy. However, once the files were transferred and compiles done on a Macintosh and a machine running Windows, the application did come up with the appropriate "look and feel" for each environment.
Bedrock was followed by an introduction to BETA, an object-oriented language which has recently entered the commercial market. See Steve Mann's article in this issue for more.
The morning ended with Doug Sleeter of Quorum Software Systems. He described Quorum Latitude which provides "virtual porting" of Macintosh applications to Unix systems by recompiling the Macintosh sources on the Unix workstation and linking with the Quorum Compatibility Engine, a portable implementation of the Macintosh API supporting System 6.0.7 and some parts of system 7.
The most heavily attended session of the afternoon was that on support for developers moving from MacApp to Bedrock. Attendees saw prototypes of two conversion tools, one for resources and one for code. The code conversion tool makes no changes, but produces a file of annotations which provide commands to highlight spots where change is needed and explain the needed changes. The primary purpose of the session, however, seems to have been to elicit feedback from the audience, and in that it was certainly successful. One complaint came from those still maintaining MacApp 2-based applications (well over half the audience) because support for that transition is not planned. The most popular statement of the session was the announcement from the back of the room that MacApp 3.0.2 will happen.
Kurt Schmucker's session on Prograph and Serius and Jeff Alger and Neal Goldstein's introduction to SBM suffered during early part of the afternoon from being up against Bedrock, but they gathered a larger audience as the Bedrock session ended.
The afternoon ended with concurrent sessions on Serius, Ad Lib, and ObjectModeler™. Nick Nallick is responding to user requests; the next version of Ad Lib will include a hierarchical view like that in IcePick™.
An Apple reception, complete with Bedrock T-shirts, was followed by a MADA town meeting giving the attending membership an opportunity to express concerns directly to both old and new board members.
The other major contender was Gary Odom's OOPC. OOPC is a dynamic object system which can be used with any standard C compiler. Both OOPC and Component Workshop are going cross-platform but aren't there yet.
ParcPlace demonstrated VisualWorks, a Smalltalk-based cross-platform application development environment for GUI-based client-server applications. It looked like a good environment. Unfortunately, the Macintosh version didn't look enough like a Macintosh application to impress the audience.
Another contender suffering from its lack of adherence to the human interface guidelines was Camelot. Camelot was technically impressive, but also suffered from a large memory footprint.
The final contender of the day was QKS's SmalltalkAgents™, a completely new Smalltalk implementation with a true Macintosh interface and toolbox access. The implementation supports System 7 features and WorldScript. For those who can afford its large footprint (1.5 to 2.5 megabytes), SmalltalkAgents looks like a promising development environment.
The evening ended with the first session of Frameworks Facts, an opportunity for the audience to question representatives of various non-C based frameworks.
Bob Krause introduced NeoAccess, a set of C++ classes that provide object persistence, and previewed NeoShare, a forthcoming offering which will support multiple users. An interesting note on NeoAccess: full source code is provided.
At this point, Steve Sinofsky of Microsoft braved the crowd to present Microsoft Foundation Classes 2.0. His reception was fairly favorable, but his response to the cross-platform question-MFC will go wherever the Windows API goes-was unpopular.
The next scheduled presenter was James Plamondon, but his technical difficulties led to a rather appropriate schedule change. Steve Wilson gave the first of his talks scheduled for Thursday and discussed porting a MacApp application to Windows. He showed us how to make Borland's OWL look as much like MacApp as possible.
The afternoon offerings were varied, with tutorials on C++, developing database applications using object-oriented frameworks, Lisp/CLOS, and developing small frameworks including problem-domain frameworks. Dave Wilson demonstrated each of Emergent Behavior's offerings and amused his audience by declaring, "My application framework is smaller than your application framework." Of course, he also demonstrated compile time of under a minute using MPW.
Wednesday evening brought the second round of Frameworks Facts. The frameworks represented were OOPC, Component Workshop, MFC, and MacApp. Unfortunately, MacApp was represented by Bob Hablutzel (later joined by Dan Strnad of DTS) because efforts to get an Apple representative ahead of time had been unsuccessful. The framework most were interested in was, of course, unrepresented.
She was followed by an introduction to Camelot, which would probably have been more effective before the exposure to it earlier in Frameworks Facts and an afternoon session on Tuesday.
Dirk Bartels of BKS Software introduced their cross-platform OODBMS POET.
The morning ended with James Plamondon's session originally scheduled for the previous day. He introduced Object Linking and Embedding 2.0 and demonstrated a prerelease version running on the Macintosh. OLE allows objects from other applications to be placed in a document using either linking (which means that it will be updated if the original changes) or embedding. The objects can be edited in place (in the case of embedded objects) or by bringing up the original document. The editing is done by either the original application or another application capable of handling that type. The new Windows version will be available soon, but the Macintosh version is still in the future.
There were two more sessions after lunch before everyone headed out to SeaWorld. First, Steve Wilson discussed writing application generators and demonstrated two provided by Emergent Behavior with their frameworks. The concept proved popular, and someone in the audience suggested that an application generator would be an appropriate replacement for Skeleton.
Lee Harris of Pillar corporation then discussed monagement of a large OOP project, using Pillar corporation's 400,000 line financial planning application as an example.
Sea++World was little disappointing since the rain we avoided Monday through Wednesday showed up on Thursday. However, the banquet itself was enjoyable, and the keynote address actually had some substance. Now don't get me wrong, Taligent still isn't talking. However, Mike Potel did give us a few facts that we hadn't heard before. First, he emphasized small frameworks and described the components of system as frameworks. Second, Pink is being developed in C++, and that will be the initial development language though others will become available. Third, Taligent will be providing "good" developer tools. Potel went on to discuss the better features of various development environments, but he made no promises regarding the specific features of the tools Taligent will provide. For now, the advice is to learn C++ and to gain experience using frameworks and then to jump on the Taligent bandwagon when the time seems right for you and your business. One encouraging feature of Mike Potel's talk was its firm grounding in the economics of software development. Following the banquet, Taligent held a reception back at the hotel at which Taligent employees were available for questioning.
Reactions to the evening were mixed. Many people felt that they had heard some new things and obviously felt more confident that Taligent is a real part of their future and is interested in them as developers. On the other hand, some felt that they had heard nothing more than they had heard before.
The LISP/CLOS overview that followed was not strictly futuristic, but was encouraging developers to move in new directions.
An introduction to Dylan followed. As many of you know, Dylan is Apple's attempted answer to the drawbacks of OODLs. For an introduction to the language, see Mikel Evins' article in this issue.
G. Gordon Apple continued the morning's focus, presenting a Direct Broadcast Satellite system currently under development which will make extensive use of object-oriented programming. For a description of the system, see his article in this issue.
The final session featured Jeff Alger's thoughts on the current state of OOP and its future. As always, his ideas are thought-provoking. They will be presented in full in the May issue of FrameWorks.
So, what was MADACON '93? It was primarily an opportunity to examine new application frameworks and other developer tools and a chance to glimpse the future. There were no clear winners (other than MacApp 3.0.2), but we saw several promising candidates.
