November 05 - 08, 2019

Crowne Plaza Houston River Oaks
Houston, Texas, USA
2712 Southwest Freeway, 77098
Phone: 1-713-5238448
Fax: 1-713-5771273

Technical Session Abstracts

Keynote — Tcl, Rust, and the Death of Rube Goldberg

Will Duquette

Rust is a new language that occupies the same niche as C: it is fast, statically compiled, and cross-platform. It is also memory-safe, avoiding most sources of memory errors. The Rust compiler uses the LLVM back-end, and runs anywhere that LLVM can target: Windows, macOS, and Linux, but also embedded applications and the Web via WASM. Rust includes a robust build manager, Cargo, making it trivially easy to build Rust libraries and applications. The speaker will discuss his experiences in implementing a Tcl interpreter in Rust, the advantages and disadvantages of a Rust-based Tcl infrastructure, and some details of the interpreter.

A first step towards end-to-end testing of subscription billing

Vishan Persaud

Always, subscription billing at FlightAware has never been "tested" and faces being deemed legacy code. Again, the code that turns work into value at FlightAware can be called untested, legacy code. Touching sensitive data, third-party APIs, and being "now" dependent creates a hydra of problems that scares development resources away. In this paper, a strategy is outlined covering everything from cloning production data to automating test runs for this body of code. It is the intention of this paper to assert a reusable and reliable way of testing code that is based upon an ever mutating relational database and how to effectively gate testing code from polluting a production environment.

Cuneiform - Implementing Document Layout with Clay

Sean Woods

When composing massive machine generated manuscripts, one is often tempted to fall back on PDF as a format of choice for digital documents. At least until one has to develop content for an international client who uses a Logographic language system.

This paper describes an object oriented XML/HTML layout system called Cuneiform. Cuneiform acts as an Tcl-Savvy object model for formats that demand a document object model. At the same time, it can leverage the similarities between XML and HTML to integrate SVG files with text.

Development of Home Care Quality Toolkit

Abir Rahman, Forhan Emdad, Gunes Koru

With the increasing need, utilization, and expenditures in home care,monitoring the quality of care provided by home health agencies and theassociated health outcomes is of interest to multiple stakeholders including the Federal and state governments, providers, and healthcare consumers. Currently,there is a lack of advanced interactive tools that can help healthcare administrators to explore and understand publicly-available datasets. To address this gap, we developed the "Home Care Quality Toolkit" following an iterative design approach. The project used Tcl/Tk, sqlite3, and gnuplot to provide a usable and useful tool to the healthcare administrators in this domain.

EdgeS(tm) a Tcl'ish Micro-services Platform EdgeShell(tm) Tool

David Simmons

As past attendees of Houston Tcl/Tk Conference may remember, I introduced TSL (text-scripting-language TCL dialect) three years ago, and then presented again the following year. I could not attend last year because I was too busy working on the new Light Phone II device we just launched this past week, where I am CTO; and I have been pretty deeply involved in Robotics and IIoT industry activities all of which are related to or involve the AOS(r) Family engine technology and TSL(tm) work. For those who may not know, AOS (Agents Object System/Agile Object System) work was commercially developed in 1990 and released in 1992 into the Apple Mac World community as a high-performance Smalltalk engine and has been alive ever since, and this is its 9th engine version.

Last year the AOS Family work on TSL was renamed as EdgeS collectively and the language dialect renamed as EdgeScript(tm). It is the primary server for "Light Phone I" cloud systems and other IIoT facilties.

The focus this past year has been on polishing and locking down the language design and syntax while still supporting TCL syntax as a part of its behavior. Past demonstrations did not show the deep and seamless integration with Fossil or SqLite. This year I will demonstrate that integration, intrinsic SSL, web-servers, markdown, XML, host-OS, and show the direct relationship between Repo-Checkin branches, packages, and modules with the code-integrity and security model it encompasses with support for versioning and zero-devops deployment.

Of particular note this year will also be sharing of the railroad diagrams for the language syntax, intrinsic auto-doc support, and discussion and demonstration of the intrinsic JSON (xjson) features of the language dialect and how they play a key role in declarative analysis of code by tools and specific features of the syntax to help tooling and discovery.

I believe that many of the language dialect variations will be of interest to those in the TCL community who may find the capabilities valuable or at least of merit in influencing the future of TCL.

As and when time permits I will be available throughout the conference for offline discussions and I will make available a version of the software to play with and utilize for experimental (non-commercial work). Of note in that comment is that certain language elements are still being finalized and I do not want to guarantee language stability at this time, it is also running on an experimental AOS interpreter that facilitates language development and not the final high-performance AOS jit execution engine.

Lessons learned, Popeye and Roadrunner

Peter da Silva

When we looked at Popeye last year, it hadn't been put into production. Since then we've had several months of experience and the new hot application under development is Roadrunner, which performs the same tracking for vehicles that are still on the ground. This talk will look at lessons learned in the productization of Popeye and how they have informed Roadrunner's development.

Mapping the Tcl world: Using Tcl to curate OpenStreetMap

Kevin Kenny

Mapping the Tcl world: Using Tcl to curate OpenStreetMap

Modern Dataflow in Experimental Nuclear Science and Tcl

Ronald Fox

The National Superconducting Cyclotron Laboratory (NSCL) is about to enter its final run period. Once the final series of experiment is complete, after a one year shutdown, we will recommission as the Facility for Rare Isotope Beams (FRIB). Data rates of FRIB experiments are expected to be several orders of magnitude higher than those of the NSCL. Several technical developments are therefore required for both online and offline data handling. Included in those developments is a new Tcl MPI package and the retrofitting NSCLSpecTcl to use that package to perform massively parallel histogramming.

Multicom - FlightAware's Alert Delivery System

Mary Ryan Gilmore

This paper examines the design, performance and durability of FlightAware's alert delivery system, Multicom. Multicom reads in all of the flight status updates that FlightAware produces and sends out flight alerts for any customer that requests them. Multicom is completely written in TCL and utilizes many new libraries like tclrmq, zookeepertcl and sqlbird. The system receives more than 35 million relevant flight status updates per day (that's 400 updates per second on average), matches them against more than 440,000 alert triggers, and sends more than 300,000 alerts each day. This system is an example of how we have used TCL to achieve great performance and scalability.

Panel: Building/Packaging

Andreas Kupries, Sean Woods

Panel: Building/Packaging

Quick and dirty I/O playing with X-Plane without "dirty" - The Tcl way

Frank Morlang

The paper describes Tcl usage in the context of interfacing with the X-Plane flight simulator. The need for a real-time flight dynamics corrector application, taking table based aerodynamic coefficients from Computational Fluid Dynamics (CFD) model experiments to overwrite X-Plane's internal flight dynamics in the supersonic and hypersonic regime resulted in the development of an interface X-Plane package in Tcl.

Realizing the theme dream

Marc Culler

The integration of the Tile project into Tk 8.5 with TIP #248 had two goals. One was to offer a better way of designing and building widgets while the other was to provide application developers with the ability to write a single script that would provide a user interface that looked good on many platforms. The first goal was largely achieved. Much progress was made on the second but, especially for macOS, it was not complete. This talk will describe recent progress towards realizing the theme dream for the Aqua theme.

Rediscovering Ousterhout's Dichotomy in the 21st Century while Developing and Deploying Software for Set-Theoretic Empirical Research: From R to Python to OCaml and Tcl/Tk

Claude Rubinson

In 1998, John Ousterhout predicted that programming in the 21st century would be dominated by the complementary use of "system programming" and "scripting" with the former being used to implement complex algorithms and data structures or when performance is critical and the latter, for connecting together pre-existing components. I offer another reason for embracing the dichotomy, arguing that the two approaches offer different opportunities for knowledge production. Using system programming languages to model complex systems and implement novel algebras aids one's deductive reasoning about a domain. Scripting's flexibility, in contrast, encourages the inductive identification of effective analytic processes and practices. While it is now standard practice to begin with and program as much as possible in a scripting language, dropping to a system programming language only when necessary, I contend that under certain conditions it is preferable to start with the system programming language. Employing as a case study the evolution of software that I have developed for implementing the research methodology of qualitative comparative analysis (QCA), I explore how the prioritization of scripting languages has hindered methodological advancement. Reimplementing the method in the system programming language OCaml allowed for certain longstanding questions to be answered and uncovered new avenues of inquiry. The scripting language Tcl/Tk was chosen to implement an extensible analytic environment that provides both a opinionated graphical interface and an embedded flexible console for conducting research using QCA.

Release the TURTLES: A Pure Tcl Interface to Dynamic Proc Tracing

Michael Yantosca

Proper dynamic program analysis requires solid collection of call frequency, relationships, and timing. Typically, this is achieved with a suite of language-centric tools, e.g., valgrind (C/C++), the GHC profiling sub- system (Haskell). Tcl appears to lack similar tools or at least requires significant language extensions to meet this need. Consequently, this work introduces the Tcl Universal Recursive Trace Log Execution Scrutinizer (TURTLES), a simple proc tracing interface that yields easily aggregated and analyzed call records. By adhering to pure Tcl, the endeavor provides an enlightening eĢtude in the pain points of developing such tooling in the language.

Serverless Tcl with AWS Lambda

Cyan Ogilvie

Serverless computing is a powerful approach for building scalable and cost effective web applications - by only supplying the functions that are core to your application, without taking on the burden of managing the infrastructure needed to host and serve those functions.

The available languages offered by the serverless provider in which to implement these functions have however been restricted to a small set of popular options like Javascript and Python, leaving Tcl programmers without access to this transformative approach.

Amazon have recently made available the option of providing a custom runtime for their serverless platform (AWS Lambda), removing this restriction. This paper describes the architecture and process of creating a custom Tcl runtime for AWS Lambda, and presents a case study applying it at scale in a production setting.

Smart Tile Grids: Optimizing the display of non-uniform geographical data

Philip Clifton

One of the core competencies at FlightAware is the efficient and effective display of flight-related data on in-browser maps. In some cases, the amount of data to be displayed is quite large, such that performance considerations come into play. This talk will walk through the process of optimizing the display of this data by embracing its inherent non-uniform distribution.

State Of Tcl, a Review

Don Porter

The Tcl Year in Review

Tcl Core Team Panel

Andreas Kupries, Kevin Kenny, Brian Griffin, Don Porter

Tcl Core Team Panel

Tcl and the Qt Event Loop (Using Tcl in a Qt Application)

Brian Griffin

Tcl and the Qt Event Loop (Using Tcl in a Qt Application)

The Sobyk Binary Distribution

Sean Woods

ActiveState has stepped out of the business of actively developing Tcl. The side effect of their absence is that the core team no longer has a reference binary distribution where the impact of new developments in the core can be measured against existing applications and production software.

Existing kit architectures do a fairly decent job of keeping up to date with released packages and integrating them into a released core. The process requires constructing a lot of boilerplate code. Some is shell script. Some is C code. And the process is made difficult by a profound lack of integration standards when it comes to package development for Tcl/Tk. This 'boiler plate' actually ends up including a lot of institutional knowledge about the quirks of each package's library requirements (often varying by platform), build system limitations, and installer quirks. All of this was information that was tirelessly gathered by the staff at Active State.

Sobyk is an attempt to develop a community version of that old knowledge base for developers of custom applications. Rather than distribute binary packages, it distributes machine readable package descriptors, that can be used by a tcl based automation to assemble kits on demand.

Tracing TCL at multiple levels

Shannon Noe

The TCL interpreter is implemented in C and TCL.

This talk explains how to trace a TCL interpreter execution at the level of TCL source, TCL byte code, C functions and system calls. With this trace information one can understand what is happening with TCL code. We will cover the technical details of implementing the trace. Then, we will look at some interesting traces of TCL.

Wapp - A super-simple yet powerful, secure, and robust framework for writing web applications in Tcl

Richard Hipp

Wapp is a framework for writing web applications in Tcl, or for adding web-access capabilities to existing Tcl programs.

Key features include:

  • Very simple API for a minimal learning curve
  • Secure by default
  • Cross-platform - works with any web server, or stand-alone
  • A single file of Tcl for ease of integration into existing projects

This talk describes Wapp and how it is different, and potentially useful in ways where previous Tcl-based web frameworks fall short.

pilights - doing fancy things with RGB LED strips using Tcl and a Raspberry Pi

Karl Lehenbauer

RGB LED strips are cool. You write three bytes of RGB data to the strip and it sets the color of the first LED. Shift registers built into the strip transfer the color previously set in the first LED into the second one, from the second LED to the third, etc. Hundreds of LEDs can be updated tens of times a second with millions of colors per LED.Initial experiments were done using an Arduino single board computer programmed in C++, and produced numerous visually interesting patterns and animations. Attempts to make visually appealing color fades, however, failed, as the LED strip had almost as much memory in its shift registers as the Arduino had RAM.A more capable computer was needed.The Raspberry Pi presented an appealing alternative. A gigabyte of RAM compared to the Arduino's four kilobytes and four 64-bit CPUs clocking at over a gigahertz versus the Arduino's single 8-bit CPU at 12 megahertz solved the performance problems. Its Linux operating system made it possible to consider running Tcl to control it. Being able to ssh in and do git pulls and compiles and installs natively on the target hardware greatly simplified development.I created the tclspi extension to be able to write to the Serial Peripheral Interface bus and the pilights extension to talk specifically to the LED strips. pilights can set ranges of pixels to specific colors, create arrays of values and cycle through them, and can even use PNG, GIF and JPEG files and emit successive rows of pixels from the image to the corresponding LEDs.This talk will include live demos of both the Arduino and Tcl/pilights versions, with all supporting software and documentation fully open-sourced.

tclws Versioning

Jonathan Cone

The tclws library provides methods for easily exposing SOAP or JSON interfaces with custom data types. At FlightAware, the package is used in both the FlightXML and MAPI services for data querying. Versioning of FlightXML has proven difficult in the past and required creation of new endpoints for verion updates with significant duplication of code. This past year, support was added to tclws to better support versioned services. The changes add parameters for indicating a required or requested version for methods, data types and documentation. With these changes a single endpoint can support multiple versions of a polling service.

Contact information

[email protected]