EuroTcl Logo
Home
Registration
Currently selected Program
Accomodation
Travel
Past Events
Sponsors
Siemens Logo

Program

General information

There will be a come-together on Friday evening for those arriving in Berlin the day before the meeting.

Program Schedule

Friday
Time TBD Come Together
Saturday
Time TBD On-site registration, Meet and Greet
Welcome
Talks
Lunch
Talks
Time TBD Social Event
Sunday
Time TBD Meet and Greet
Talks
Lunch
Talks
Time TBD Conclusion, Goodbye

Talks and Presentations

Florian Murr
Franz Vater
Christian Gollwitzer
Uli Ender
Manfred Rosenberger
Florian Murr
McFSM - A Vast Extension to Finite State Machines

McFSM (Multiple coupled Finite State Machines) is a new theory and a new paradigm to create Finite State Maschines (FSMs) with huge state spaces.
This makes this new kind of FSMs practical in new areas, quite apart from their traditional use. What makes FSMs so appealing is the fact that their properties can be proven at compile-time. This is in contrast with Turing-complete code which has to resort to runtime-testing, because no proofs are possible at compile-time.
McFSMs greatly extend the applicability of FSMs into domains that were previously only accessible with Turing-complete code, while retaining most of the provability. McFSMs require a new theory, a DSL (Domain Specific Language) and an IDE (Integrated Development Environment).

The current prototype is a transpiler IDE written in TclOO and Tk, with persistent data-structures in SQLite, that generates code in various programming languages.
A paper about McFSM has been accepted for the ICSE-2017, with a preprint that can be found at http://arxiv.org/abs/1702.07951

Franz Vater
Organizing information, projects and communities by an information server based on tclhttpd

For applications like for project management, issue tracking, organisation and distribution of information or the organisation of teams and communities web based solutions are the first choice.
But the better known frameworks in this area all suffer from the same flaw: The do not use or support Tcl!

InfoServer wants to change this. Although not yet fully fledged it shows a way to build a portal server based on the tclhttpd web server and a flexible and powerful template system.
Currently it addresses smaller enterprises and communities with the need of cooperation of internal and external groups and persons.
InfoServer offers the management of persons and overlapping groups and strict access control on a single document base.

For the storage of system and customer data interfaces for SQLite3 and PostgreSQL databases are available. The predefined features include skins, dynamic document generation and merging, user database queries, online editing and more.
The layer of template processing is realized with pure Tcl and is the base to create all kinds of services like a wiki, issue tracking or project management.

Christian Gollwitzer
Controlling Large-Scale Experiments with AsynCA, a modern Tcl extension for EPICS channel access

EPICS (Experimental Physics and Industrial Control System) is a distributed soft real-time control system for scientific instruments, which is in use at several large scale experimental facilities, for example the synchrotron radiation facilities APS in Argonne and BESSY II in Berlin, and the experimental fusion reactor ITER in France.
EPICS enables the reading from and writing to so-called process variables (PVs) distributed over the network via the channel acess protocol (CA) with zero configuration. These PVs typically represent a measured value or setpoint, e.g. the reading of a voltmeter or the goto position of a motorized axis. All I/O operations on PVs are performed asynchronously.

AsynCA is a Tcl extension which wraps the canonical EPICS libraries for channel access. In contrast to the older interfaces ET and epicstcl, it works with Tcl 8.6 and provides fully asynchronous, thread-safe operation by integration with the Tcl event loop. It is the only available extension for Tcl which also allows to create PVs by wrapping the server library in addition to the client libraries. Currently, the EPICS callbacks are translated into Tcl callbacks which are run from the event loop. Synchronous versions of the command are based on vwait. A future version of AsynCA will implement synchronous commands based upon coroutines to facilitate asynchronous programming with EPICS.

Uli Ender
Using GPIOs of Raspberry Pi in pure Tcl - my way

In the recent years the Raspberry Pi has become a popular low-cost mini-computer. When you run Debian-Wheezy-Linux on it, Tcl is already on-board.

Scripting in pure Tcl using simple commands like "open, puts, read, close" with /sys/class/gpio and /proc/interrupts, you can already toggle the GPIO lines several hundred times per seconds or count impulses. This is enough for a lot of uses of this little computer. Via WLAN interface and a small server script you can also load, store and source Tcl scripts without being directly connected.

There is already a library written in pure Tcl published by Gerhard Reithofer. In my talk instead, I want to demonstrate my way of programming the GPIO-lines of the Raspberry Pi.

Manfred Rosenberger
Refactoring approaches for rattleCAD, a domain specific CAD-application written in pure Tcl

rattleCAD is an open source CAD software that supports bicycle frame builder in building customized bicycle frames. Based on a wireframe geometry rattleCAD visualizes the new bike with all its parts and creates drawings for the workshop.
rattleCAD is written in pure Tcl and is hosted on sourceforge.

When rattleCAD started as a prototype in a sandbox there was no plan to start a professional software development, nor was any software architectural approach defined. Nevertheless, more and more functions were implemented, and the code of rattleCAD became more and more complex. Implementing new functionalities and fixing any bugs became a time-consuming process. In order to achieve different characteristics of software quality rattleCAD had to be refactored, to maintain and extend rattleCAD in the future.

To make rattleCAD maintainable a suitable software architecture approach had be found and to be implemented. With the implementation of TclOO as an object-orientated approach in the Tcl 8.6 core, this approach was used to support the refactoring of rattleCAD.
According to an analysis, rattleCAD was decomposed into individual, separable areas and reorganized without reimplementing rattleCAD totally new. While TclOO helps to organize objects, the separation of the user interface (GUI) from the business logic bases on mapping tables.

This contribution will show the capabilities of Tcl in the implementation of a CAD application and gives a view on software architecture approaches in case of refactoring a software written in pure Tcl.