EuroTcl Logo
Currently selected Program
Past Events
Siemens Logo


General information

There will be a come-together on Friday evening for those arriving in Berlin the day before the meeting.
We will meet in the Ristorante Mamma Mia, Nonnendammallee 86, which is in walking distance from the recommended hotels.
It will start at 18:00 and you can join anytime depending on your arrival time.

The social event will start at 18:30 with a guided city tour through Spandau.
Afterwards we will meet in the restaurant Satt und Selig.

Program Schedule (Preliminary)

18:00 Come Together
09:00 09:45 On-site registration, Meet and Greet
09:45 10:00 Welcome
Session: Testing with Tcl
10:00 10:30 Steve Shaw HammerDB, load testing and benchmarking databases with Tcl/Tk
10:30 11:00 Adrien Peulvast TBC: Use of BLT (RBC) and canvas in the testing of metro systems
11:00 11:30 Coffee break
Session: Tcl Applications
11:30 12:00 Franz Vater Organizing information, projects and communities by an information server based on tclhttpd
12:00 12:30 Manfred Rosenberger Refactoring approaches for rattleCAD, a domain specific CAD-application written in pure Tcl
12:30 14:00 Lunch
Session: New Developments
14:00 14:30 Florian Murr McFSM - A Vast Extension to Finite State Machines
14:30 15:00 Nathan Coulter An Event Loop For Coroutines
15:00 15:30 Coffee break
Session: Work in Progress
15:30 15:50 Arjen Markus Renewal of a tutorial
15:50 16:10 Arjen Markus Mathematcl
16:10 16:30 Donal Fellows TBC: Status of Tcl compiler tclquadcode
16:30 17:30 All State and Future of Tcl. Discussion with TCT members.
18:30 Guided City Tour
19:30 Social Event in Restaurant Satt&Selig
09:00 09:30 Meet and Greet
Session: Mechanical Simulations with Tcl
09:30 10:00 Alexandru Dadalau Mechanical Simulations with Tcl/Tk
10:00 10:30 Leonid Vovchuk Tcl as automation tool in mechanical calculations
10:30 11:00 Coffee break
Session: Experimentation and Simulation with Tcl
11:00 11:30 Christian Gollwitzer Controlling Large-Scale Experiments with AsynCA
11:30 12:00 Carsten Bellon aRTist - A computer simulation of industrial radiography
12:00 13:30 Lunch
Session: Last but not least
13:30 14:00 Uli Ender Using GPIOs of Raspberry Pi in pure Tcl - my way
14:00 14:30 Han The IPEnv. A Tcl/Tk-based integrated programming environment
14:30 15:00 Conclusion, Goodbye

Talks and Presentations

Florian Murr
Franz Vater
Christian Gollwitzer
Uli Ender
Manfred Rosenberger
Carsten Bellon
Leonid Vovchuk
Steve Shaw
Alexandru Dadalau
Nathan Coulter
Arjen Markus
Arjen Markus
Donal Fellows
Adrien Peulvast
Han The
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

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.

Carsten Bellon
aRTist - An Industrial-Radiology Simulator Using Tcl/Tk and VTK

Industrial radiography or Radiographic Testing (RT) is a method of non-destructive testing where many types of manufactured components can be examined to verify the internal structure and integrity of the specimen.
The computer program aRTist can generate synthetic radiographs from a virtual RT test set-up. In the field of industrial radiology simulation is used, e.g. to optimize techniques for complex applications, to support the preparation of written procedures, and for education purposes.

The simulator aRTist combines analytical and Monte Carlo methods to efficiently model the radiation transport. The program comes with a graphical user interface written in Tcl/Tk. In combination of Tcl/Tk and the 3D capabilities of the visualization toolkit (VTK) a practical and convenient simulator has been realized.
This will be illustrated by discussing application scenarios of classical radiography, X-ray computer tomography, and X-ray backscatter imaging. Additionally, some insight to the software implementation of the simulator will be given.

Leonid Vovchuk
Tcl as automation tool in mechanical calculations

FEM-based engineering calculations include many routine operations, which create great scope for automation. This is especially actual for serials calculations like optimization, where automation increases the number of tested configurations and thus the quality of accepted decisions, even without use of optimization algorithms.

Tcl proved itself as a convenient tool to automate various external applications and to write own specialized applications. A meta language for Patran Command Language was implemented as a Tcl package, which adds visibility and flexibility to work with this popular pre- and postprocessor.

The native link of Tcl to C with the possibility of embedding of C-level data and methods bring the necessary performance when dealing with large amounts of data, which is important, for example, in calculating of derived results during posttreatment.

Finally, a set of Tcl packages and applications is demonstrated which manage a whole cycle of calculations from model creation to archiving and disposal.

Steve Shaw
HammerDB, load testing and benchmarking databases with Tcl/Tk

HammerDB is a graphical open source database load testing and benchmarking tool hosted on sourceforge. Originally called Hammerora for Oracle Database this tool has grown to support Microsoft SQL Server, IBM DB2, MySQL, PostgreSQL and others with pre-compiled packages available for Windows and Linux platforms.

Written in Tcl using Tcl database extensions and TDBC, HammerDB has become the industry standard tool for simulating industry standard database benchmarks with hundreds of published white papers and benchmarks.

This session introduces HammerDB from a Tcl development perspective and in particular how the Tcl threading model has enabled the building of an application that drives database performance to many millions of transactions per minute. It covers how Tcl is used to build database schemas, run and monitor workloads and capture and analyse performance metrics.

Details are given on the Tcl extensions and packages used and any modifications made as well as the development challenges of growing from working with one database to multiple database platforms.
Looking ahead there are plans to add support for additional databases and workloads with many new Tcl database extensions now available.

Alexandru Dadalau
Mechanical Simulations with Tcl/Tk

Finite Element Analysis (FEA) software is usually a heavy software with tens of GB installation footprint.

We demonstrate how Tcl/Tk and C can be used to create a very lightweight and portable FEA software for simulating component oriented, highly configurable and parametric mechanical assemblies.

Nathan Coulter
An Event Loop For Coroutines

The built-in Tcl event loop, implemented in C, runs in a tight loop, processing events placed into its queues by various resource schedulers.

A similar system is implemented in Tcl using a coroutine that acts as a trampoline, taking itself off the stack each time it processes an item in its queues.
This scheduler was factored out of {ycl coro relay} and generalized to facilitate reuse.

Arjen Markus
Work-in-Progress: Renewal of a tutorial

More than 10 years ago David Welton, Neil Madden and I among others converted the interactive tutorial as developed and maintained by Clif Flynt into a non-interactive online version.
The idea was that this would make it easier to maintain it and as it was directly online, it would be easier for people to access it. This is partly true - it is visible - but it is also not actively maintained.

Since then, Tcl has undergone quite some development - think coroutines and TclOO but also TDBC and Critcl. We have seen many developments in the computing landscape as well. It is time for a renewal: expose those new features and show users how Tcl fits nicely in today's world.

Arjen Markus
Work-in-Progress: Mathematcl

Extending Tcl by compiled libraries is relatively easy, especially if you do it on an ad hoc basis. It becomes a bit more cumbersome if you intend to make packages that can be widely used - you need to deal with distribution issues and the idiosyncracies of all the platforms and operating systems people use.
The Tcl Extension Architecture is one solution, but it does not quite fit the MS Windows system and it does not cater for, say, Fortran libraries.

The goal of Mathematcl is to make (classical) mathematical/numerical libraries such as LAPACK or QUADPACK available to Tcl programmers, in such a manner that:

  • the interface is "natural" for Tcl
  • the packages are available at minimum expense - merely run a build/install script and eh presto! you are up and running
  • you can use the packages on "any" platform
But most importantly, it provides a wealth of libraries for all manner of mathematical and numerical tasks.

Donal Fellows
TBC: Status of Tcl compiler tclquadcode

No abstract available yet.

Adrien Peulvast
TBC: Use of BLT (RBC) and canvas in the testing of metro systems

No abstract available yet.

Han The
IPEnv. A Tcl/Tk-based integrated programming environment

IPEnv is a Tcl/Tk-based integrated programming environment. It comprises a file manager, a multilingual editor (Tcl/Tk, C++, html/css/js), a fully-enabled console, and gives access to several tools and utilities.

"Tcl/Tk-based" does not mean that it is written in Tcl/Tk. It refers to the console in the first place, which has been developed to a mature shell, merging Tcl/Tk into the Windows OS environment. This includes running Tcl/Tk processes in the background, redirecting Tcl output, and the ability to interrupt processes, both external and Tcl. Moreover, IPEnv has implemented several Tcl extensions, such as Tktable, TkHtml, TclCurl, Thread, and TclMagick to offer additional functionality.

IPEnv is a truly innovative environment. There are several goodies that will be demonstrated during the talk.