The Macintosh at that time had no inter-process communication (IPC). Kleiman created the an IPC module for the Mac to allow MacFrames to communicate with other processes; in particular, with HyperCard. This allowed HyperCard to be used as a visual programming front-end for MacFrames, without additional effort. (This original IPC module was released as an init and adopted by others.)
Another goal of MacFrames was to build distributed processing right into the object system. The idea was that, instead of using an RPC API (e.g., RESTful services), one should be able to simply declare a property to be distributed; that is, it would know its endpoint and other properties. Thus, communicating with a remote process would be as simple as setting the object's property with the desired value and callback for the results.
MacFrames was used by Apple's QA group to create an automated black-box testing system. This success permitted the SK8 project to expand.
Once the infrastructure was in place, the next goal was to develop the graphics object library. The idea was to develop objects from the most primitive level (points, lines, etc.) and create composite objects based on them. One design question was: how "heavy" would these objects eventually be? That is, to support as many conceivable uses of an object without additional programming, how complex would they become? The solution was to make them as heavy as they needed to be, but to hide the complexity through the visual programming development environment by managing the context. The logical conclusion was: SK8 would not just be a visual development environment; rather, it would be a visual development system development environment. In other words, development environments targeting different application areas would be built on SK8. Each application-oriented environment would manage the context under which a SK8 object's complexity could be hidden (or stripped away with smart SK8 object compilers that understood the interdependencies of each object's component). [NB: Adobe Air's ActionScript objects were heavy, but there was only one Builder for all applications, so truly visual programming was difficult.]
The first version of the SK8 graphics system had, as a test target, to extend HyperCard, but to allow cards to have multiple layers rather than a single "background" template. Around this time (1989), SK8Script (originally named AppleScript), a prototype for the first specification of the AppleScript language, was created. A number of researchers in the Advanced Technology Group began to use SK8 for their projects. Certain universities and corporations also began to participate. The system was used to develop prototypes for Newton, QuickTime interfaces, interprocess communication, and was used to prototype many titles, including Stagecraft, a learning tool for children.
For performance reasons, in 1992 and 1993 SK8 was re-implemented from the ground up. Working at Apple's Cambridge Research Center, the Macintosh Common Lisp object store was isolated and directly hooked into SK8's store. The SK8Script debugger was re-implemented at the assembler language level (previously in Lisp) and the compiler and runtime performance improved.
A further idea was to create an infrastructure for glueing objects in some general but powerful ways, but by separating the concerns of the glue from the behavior and structure of the objects). Using metaphors like wiring and ports, objects could work in concert. The SK8 Project Builder was created to provide a very rich set of direct manipulation tools, including tools for building interactive controls and general but non-invasive glueing. The builder's objective was to provide a visual/direct manipulation interface for building visual development environments.
The SK8 system includes the object system, the graphics and component objects, the SK8Script language, and the Project Builder environment.
SK8's universe was made up of a multimedia-oriented system using Actors on a Stage. Actors were any objects that were based on the prototype Actor object, which contained the basic framework needed to provide 2D graphics support - the location and size of the object for instance. Actors became visible when they were placed upon the Stage, an invisible background object that captured user events to provide interactivity. In SK8, a traditional window was an object like any other graphics object. When an Actor was on the Stage, it could behave as a window-like object,. It was easy to design complex objects that behaved like windows (e.g., a donut-shaped window; its hole's opacity 0%, with content being a text object scrolling around or perhaps a movie playing within its frame). An object known as the "halo" provided resize handles and other affordances for meta-manipulation in a visual development environment.
All SK8 Actors could contain other actors. The hierarchy could be navigated using the chunking expressions, so one could
set the visible of the first Rectangle in CoolOval to true. The objects could then be made visible in the UI by moving them onto the Stage using the
insert command, like
insert CoolOval into the stage, which would make both the oval and rectangle appear.
GUIs were constructed solely from Actors. A window-like object could be built out of an opaque rectangle containing other objects (e.g., close buttons, widgets). sWww.youjizz.com Mypicturessite.com My Pictures Site SK8 - pedia, the free encyclopediaq w Family cWww.youjizz.com Mypicturessite.com My Pictures Site SK8 - pedia, the free encyclopediav Www.youjizzz.com