Wafe provides a flexible and easy to use interface to the X Toolkit (Xt) and the Athena widget set (Xaw) using the embeddable command language Tcl [1]. It allows access to Xt’s functionality from all compiler and interpreter languages, provided that they can communicate over stdout and stdin via unbuffered I/O. A typical Wafe application consists of a frontend process and an application program, which is executed as a child process of the frontend. Wafe provides a relatively high level interface to the X Toolkit and widget programming, where the user interface can be interactively developed without any need to program in C. Wafe can be used as a rapid prototyping tool and allows easier migration from existing ASCII based programs to X Window applications.
All content in this area was uploaded by Gustaf Neumann
Content may be subject to copyright.
A preview of the PDF is not available
... XWMF is supported by a tool suite in order to create, process, and analyze its models. All tools are written in Extended Object Tcl (XOTcl) [Neumann and Nusser, 1993] and in Prolog. As WOCM has an RDF representation a number of tools have been developed to facilitate RDF editing and processing. ...
... The basis of Cineast is the prototyping environment Wafe [Neumann and Nusser (1993)]. It combines Tcl as a scripting language with different widget sets such as the Athena widget set or the Motif widget set. ...
This paper presents an architectural implementation for Web-based, active documents. Although several approaches for distributed, active documents exist already, we decided to establish a new model which provides more flexibility and interoperability without giving up formality. The model is based mainly on the Extensible Markup Language (XML) and makes use of the Document Object Model, Cascading Style Sheets and the Intrinsic Event Model, which are all open standards defined by the W3 Consortium.
This paper describes the object-oriented scripting language XOTcl
(Extended OTcl), which is a value added replacement of
OTcl. OTcl implements dynamic and introspective language
support for object-orientation on top of Tcl. XOTcl includes
the functionality of OTcl but focuses on the construction,
management, and adaptation of complex systems.
In order to combine the benefits of scripting languages with advanced
object-oriented techniques, we extended OTcl in various ways: We
developed the filter as a powerful adapation technique and an
intuitive means for the instantiation of large program
structures. In order to enable objects to access several
addition-classes we improved the flexibility of mixin methods by
enhancing the object model with per-object mixins. We integrated
the object system with the Tcl namespace concept to provide nested
classes and dynamic object aggregations. Moreover, we introduced
assertions and meta-data to improve reliability and
self-documentation.
W a f e provides a exible and easy to use interface to the X Toolkit Re-lease 4, 5 or 6 (Xt), the Athena widget set (Xaw) and (incomplete) to the OSF/Motif widget set Versions 1.1.x, 1.2.x or 2.0 (Xm). W a f e is im-plemented using the embeddable command language Tcl. W a f e allows access to Xt's functionality from all compiler and interpreter languages, provided that they can communicate unbuuered over stdout and stdin. Furthermore, W a f e can be used with Tcl scripts for easily creating new X Window Applications or user interfaces to existing Unix commands.
Generally, a multitude of tools is used for the management of a Web application life cycle. It is highly desirable to provide
an exchange format for such tools to enable interoperability. This paper presents an eXtensible Web Modeling Framework (Xwmf), which applies the Resource Description Framework (RDF) to Web engineering to provide an interoperable exchange format.
Our proposed framework makes use of one and the same (meta-) data model to specify the structure and content of a Web application,
to make statements about the elements of a Web application, and to reason about the data and metadata. Xwmf is extensible, because schemata defining additional vocabulary to integrate new design artifacts can be added. The Xwmf tools are able to convert the Web application (metadata) description into the corresponding Web implementation.
Scripting languages are designed for glueing software
components together. Such languages provide features like dynamic
extensibility and dynamic typing with automatic conversion that make
them well suited for rapid application development. Although these
features entail runtime penalties, modern CPUs are fast enough to
execute even large applications in scripting languages efficiently.
Large applications typically entail complex program structures.
Object-orientation offers the means to solve some of the problems
caused by this complexity, but focuses only on entities up to the
size of a single class.
The object-oriented design community proposes design patterns as a
solution for complex interactions that are poorly supported by
current object-oriented programming languages. In order to use
patterns in an application, their implementation has to be scattered
over several classes. This fact makes patterns hard to locate in the
actual code and complicates their maintenance in an application.
This paper presents a general approach to combine the ideas of
scripting and object-orientation in a way that preserves the
benefits of both of them. It describes the object-oriented scripting
language XOTcl (Extended Object Tcl), which is equipped with
several language functionalities that help in the implementation of
design patterns.
We describe a software technology that is “people oriented”, in the sense that it allows us to:
specify a task as English syllogisms, together with tables of facts,
run the specification consisting of English syllogisms directly,
ask questions in English,
get hypertexted English explanations of answers,
automatically fill in business forms, and
to automatically generate database queries and updates.
In our approach, English words take their meaning from their context, rather than from a separately maintained dictionary and grammar. This makes it easy to write down knowledge with specialized words and phrases, such as “Environmental Protection Agency Form R”, and then to run the knowledge directly. The knowledge in a specification is directly compiled and interpreted according to a formal theory of highly declarative knowledge. This eliminates the troublesome and expensive gap that often arises between a specification of a task and a program that is supposed to do the task, by eliminating the program. It is not necessary to know about the theory in order to write and to run specifications.
The technology is used to automatically fill in report forms about chemical usage that are submitted to the U.S. Environmental Protection Agency. One such form has over 300 entries per chemical reported, and there are significant penalties for incorrect entries, both for an organization and a private individual who signs the form. Our technology allows us to click on a form entry to see a step by step explanatory audit trail, showing how government regulations, plus engineering expertise, and data about chemicals, were used to automatically make the entry. Other uses of the technology include the mining of medical databases, business case justification, enterprise modelling, and experiments in knowledge based document routing within an organization.
SUMMARY We describe Slisp (pronounced 'Ess-Lisp'), a hybrid Lisp-C programming toolkit for the development of scriptable and distributed applications. Computationally expensive operations implemented as separate C-coded modules are selectively compiled into a small Xlisp interpreter, then called as Lisp functions in a Lisp-coded program. The resulting hybrid program may run in several modes: as a stand-alone executable, embedded in a different C program, as a networked server accessed from another Slisp client, or as a networked server accessed from a C-coded client. Five years of experience with Slisp, as well experience with other scripting languages such as Tcl and Perl, are summarized. These experiences suggest that Slisp will be most useful for mid-sized applications in which the kinds of scripting and embeddability features provided by Tcl and Perl can be extended in an efficient manner to larger applications, while maintaining a well-defined standard (Common Lisp) for these extensions. In addition, the generality of Lisp makes Lisp a good candidate for an application-level communication language in distributed environments.
Die Arbeit beschäftigt sich mit der Implementierung von Informationssystemen, die mittels Web-Techniken wie etwa der Hypertext Markup Language (HTML), des Hypertext Transport Protocols (HTTP) oder der Extensible Markup Language (XML) erstellt werden. Web-basierte Informationssysteme werden verstärkt eingesetzt, um vollständige Applikationen für die Abwicklung von Geschäftsprozessen zu implementieren. Die Ausgangslage für die Arbeit ist das Fehlen formeller Modelle, mit der solche Systeme umgesetzt werden können, kombiniert mit dem Aufkommen neuer Anwendungsgebiete wie der Business-to-Business-Kopplung mittels Web-basierter Systeme. Im Verlauf der Arbeit werden bestehende Systeme analysiert um darauf aufbauend die Anforderungen für ein Modell zur Beschreibung und Realisierung Web-basierter Anwendungen festzulegen. Das daraus entwickelte Modell stellt die Information, die in solchen Anwendungen ausgetauscht und verarbeitet wird, in den Vordergrund, und setzt als wichtigstes Beschreibungsmittel Hypertextdokumente ein, welche um aktive Komponenten ergänzt zu aktiven Hypertextdokumenten (AHDs) werden. Das Modell für aktive Hypertextdokumente (AHDM) umfaßt ein Informationsmodell, welches den Aufbau aktiver Hypertextdokumente beschreibt, ein Kommunikationsmodell zur Regelung des Informationsaustausches, ein Objektmodell für die Definition des Zusammenspiels der aktiven Bestandteile eines AHDs und ein Laufzeitmodell für die tatsächliche Ausführung der aktiven Bestandteile. Aktive Hypertextdokumente werden als XML-Dokumente realisiert, die entsprechend dem Informationsmodell neben den ursprünglichen Nutzdaten auch Funktionen und Variablen enthalten. Neben dem Modell wird auch eine Vorgehensweise beschrieben, die den Einsatz aktiver Hypertextdokumente erleichtern soll. Die Praktikabilität des Modells wird anhand von Beispielanwendungen demonstriert, die von einfachen, eigenständigen Anwendungen hin zu kooperativen, vernetzten Anwendungen mit mobilen Dokumenten reichen. Die zur Nutzung aktiver Hypertextdokumente notwendigen Werkzeuge werden ebenfalls beschrieben.
Tcl is an interpreter for a tool command language. It consists of a library package that is embedded in tools (such as editors, debuggers, etc.) as the basic command interpreter. Tcl provides (a) a parser for a simple textual command language, (b) a collection of built-in utility commands, and (c) a C interface that tools use to augment the built-in commands with tool-specific commands. Tcl is particularly attractive when integrated with the widget library of a window system: it increases the programmability of the widgets by providing mechanisms for variables, procedures, expressions, etc; it allows users to program both the appearance and the actions of widgets; and it offers a simple but powerful communication mechanism between interactive programs. This paper will appear in the 1990 Winter USENIX Conference Proceedings ############################# The work described here was supported in part by the National Science Foundation under Grant ECS-8351961. Tcl: An Embeddab...
This paper describes a new toolkit for X11 called Tk. The overall functions provided by Tk are similar to those of the standard toolkit Xt. However, Tk is implemented using Tcl, a lightweight interpretive command language. This means that Tk's functions are available not just from C code compiled into the application but also via Tcl commands issued dynamically while the application runs. Tcl commands are used for binding keystrokes and other events to application-specific actions, for creating and configuring widgets, and for dealing with geometry managers and the selection. The use of an interpretive language means that any aspect of the user interface may be changed dynamically while an application executes. It also means that many interesting applications can be created without writing any new C code, simply by writing Tcl scripts for existing applications. Furthermore, Tk provides a special send command that allows any Tk-based application to invoke Tcl commands in any other Tk-ba...
