Short Description of Talks

Relational algebra for Tcl: introducing Ratcl and Rasql by JCW

There are a number of ways to manage data in Tcl, from native lists and arrays to various database bindings.  The choice involves trade-offs regarding persistence, robustness, performance, memory use, query capabilities, scalability, portability, standards conformance, and convenience.  This is an issue even for simple scenario's, given Tcl's limited support for data structures.  A new approach will be presented which is based on relational algebra, supplied through two packages: Ratcl, which provides a relational algebra extension that fits naturally with Tcl.  And Rasql, which provides a layered SQL interface for those who prefer it.  Both are based on over a decade of experience gained with Metakit's vector-oriented internal data model, and use a new very compact and efficient C-coded engine called Thrive.  Ratcl introduces a terminology and set of conventions which minimize the impedance mismatch caused by having databases added on instead of native persistence and query support, while Rasql takes this one step further to map standard SQL queries onto Ratcl.  Working examples will be presented, along with performance results so far.  This covers the first phase, which focuses on access and querying.  The second phase is work in progress and will also be briefly described - it deals with modifications, transactions, and multi-user scenario's.



Marrying Tablelist with Tile by Csaba Nemethi

The talk consists of two parts.  The first one is a presentation of the multi-column listbox package Tablelist, with emphasis on the many new features incorporated into it since my first presentation three years ago in Munich.  The most notable of these are the interactive cell editing and the support for embedded windows and title columns.

The second part concentrates on two aspects of using the new tile widget engine in connection with tablelist widgets.  The first one is the interactive cell editing with the aid of some of the currently available tile widgets.  The second aspect is related to the overall look & feel of tablelist widgets.  The talk presents the current state of my efforts aimed at using as many tile components as possible in the widget hierarchy making up a tablelist widget, resulting in a.nice look & feel, compatible with the currently used tile theme.  It also reports on some tile-related problems that make this work less easy than it could be.



Making Tcl "legacy" code object oriented by Artur Trzewik

Man könnte es nennen: "XOTclIDE next steps" oder "Objectorientation with XOTclIDE". Die Objektorientierung mit Tcl wird letzte Zeit wieder heiß diskutiert. Interesant könnte sein, eine Darstellung wie man ein herkömmliches Tcl-Programm zu XOTcl umwandelt und welche Vorteile
oder Nachteile sich dadurch ergeben.


Collaborating applications: Tequila takes Tcl further by JCW


Tequila is a "middleware" kind of infrastructure written in pure Tcl, which makes it easy to write collaborating applications.  A first version has been extremely effective and succesful in two very different projects: a distributed telephone system testing system which has processed a quarter million daily events non-stop for over a year, and a highly interactive multi-session chat and discussion board used in high-school collaboration research.  Several other projects have demonstrated the convenience of having such a generic and robust infra-structure.  The next generation of Tequila will be presented, aimed at providing an even richer foundation to build on.  It is heavily influenced by the first version as well as by GroupKit, a generic collaboration environment developed at the University of Calgary.  Examples will be presented of how the new design simplifies building collaborative applications, such as a basic chat system in just a few dozen lines of Tcl.  Tequila supports structured data and automatic persistence, which has a major impact on how clients and servers are designed.  The basic components (pools, rpc endpoints, notifiers) will be presented to show how Tequila enhances Tcl's strengths, i.e. seamless integration of the Tk GUI with networking and persistence.



Biotcl - a framework for computing biology by Detlef Groth
   *	Tcl becomes was Perl, Python, Java, Ruby already have
* Snit, Metakit and minihttpd as the foundation for framework development
* Starkits as the delivery platform
* no install step
* biotcl.kit - one file - will contain applications, libraries, webserver and documentation



Abstract

Currently from the four most important scripting languages (Perl, Python, Tcl and Ruby) only Tcl is missing a structured framework of tools and applications for computational molecular biology. This is a surprising issue because its clear syntax, high portability and extensibility makes Tcl an ideal choice as a scripting language for biological problems. We will present the status of our ongoing biotcl project [1]. The principal suggestion it that we will restrict mostly to tcl only libraries in order to achieve maximum portability. The following libraries will be the basis for developing biotcl-applications and libraries:

* Snit as the object oriented extension
* Metakit as RDBMS possibly with tsql4mk as SQL-Layer on top
* a small embedded webserver based on minihttpd

Applications, Libraries and Documentation (Wiki/HTML format) will be
delivered as one single starkitfile only in order to simplify
installation, maintainance as much as possible.

Sharpen Up Your Act by Brian Passingham

+ Introduction
- Vignette and "TCL"
- Typical Vignette codebase characteristics

+ Tcl Tools
- Survey of available tools
(ActiveState/T-IDE/Nagelfar etc)
- Why they can't be used in the Vignette context

+ Sharpen Approach
- Design of parser and supporting XML "interface definitions"

+ Other Related Work
- All I've found so far is Stefan Vogel's TrapEd

+ Current Status
- A "lint" for Vignette

+ Future
- Design recovery
- Code transformation
- Refactoring editor for Tcl???

+ Q&A





VCRI by Marcel Broeken and Jos Jaspers


Background

In the PRO-ICT project a groupware environment has been created, to facilitate collaborative writing in project based learning assignments in secondary schools. In this VCRI (Virtual Collaborative Research Institute). The base environment of VCRI included three tools: a database of relevant historical information sources (Database), a chat facility for deliberation between the students (Chat) and a shared text processor (Co-writer). The Co-writer allows the students to work on the texts of their assignments simultaneously. Visualization of argumentative ideas (Diagram), selection within sources (Selector) and publishing of intermediate results (Publisher) were supported by cognitive tools. Meta-cognitive tools supported the planning (Planner), monitoring (Logbook) and reflective activities (Reflector) of the students. With the Coach program, the teachers could monitor the progress of their students and provide feedback to the group or to individual teams. Screen dumps of the tools can be found at the project website: http://edugate.fss.uu.nl/vcri.

 

Outline of the presentation:

 

What is the VCRI?


A bit of history


Who uses it?


Architecture


Tools


Problems


Solutions


Future

 


Drawing diagrams by Arjen Markus


The "What you see is what you get" or WYSIWYG paradigm is so commonly
used in computer applications these days that you would almost forget
that there are other solutions too. The problem with WYSIWYG is twofold:
first of all it can lead to very complicated user-interfaces - all
functionality has to be reachable by a few mouse clicks. So we end up
with a myriad of menu options, dialgoues and toolbars just to fit them
all into the screen somewhere. The second troublesome aspect of WYSIWYG
is this: what happens if you are not satisified with what you see? You
go and try to make it look better. In other words: it distracts from the
contents. One type of application where this is very evident is drawing
diagrams.

Typical diagrams are: flow diagrams, UML-style diagrams, diagrams
showing some computer network or organograms. It is tedious to manually
align the rectangles and circles, to centre the text and so on. Instead
you need to draw a high-level object - a box with associated text, an
arrow that is attached to two such objects, location and orientation
should be relative to other objects.

This article describes a little package, loosely based on the once
famous PIC drawing package, that provides a command-driven approach to
drawing diagrams. It illustrates the use of this technique in several
practical cases.



Doing 3D with Tcl by Paul Obermeier

1. Overview of existing solutions
+ Light-weight solutions: OpenGL Tcl-Bindings (tkogl, togl, ...)
+ Heavy-weight solutions: Tcl-Bindings of graphic APIs (Nebula, iVRS,...)

2. My personal wish-list
+ Light-weight OpenGL binding
+ BSD License
+ Highly automated (Swig generated IF)
+ Full scriptable OpenGL interface
+ Expandable with C-modules

3. Implementation issues
+ Currently in work