The annual ActiveState of Tcl presentation
Tk has been supported on the Mac since the mid-1990s, but has undergone more frequent and radical changes that other platforms. This talk will touch on Tk's history on the Mac, the ongoing challenges to keep the toolkit current with the Mac's frequent API changes, and its current place in the Mac's ecosystem--and the Mac's current place in Tk's ecosystem. Finally, the talk will cover some best practices for application development using Tk on the Mac, and porting your Tk application to the Mac.
The Athena Regional Stability Simulation was designed as a monolithic TCL/TK application supporting one simulation scenario at a time. The simulation and data management code the core of the application consisted of over fifty-thousand lines of code divided across many modules, many of which were singletons providing resources to the entire application. This code has since been extracted into a scenario class supporting any number of simulation instances within a single application. The resulting implementation uses a novel Snit-based approach to creating facades for complex object-oriented libraries.
Tcl has long supported libraries for arbitrary-precision arithmetic, that is, arithmetic over fixed- or floating-point numbers with an arbitrary number of digits. One problem with arbitrary-precision arithmetic is that it is sometimes quite difficult to specify in advance what precision of intermediate results is required to achieve a desired precision in the output. This paper presents an implementation of exact arithmetic, in which numbers are represented in terms of the algorithms that produce them, with well-defined composition rules for arithmetic operations, powers and roots, and the elementary functions. It gives a gentle introduction to the theory of the exact reals (including the undecidability of equality) and shows how various computations can be performed with arbitrary precision of results (not just of intermediate values). While the implementations are likely too computationally intensive to be used for day-to-day calculation, they are of use in software testing (validation of limited-precision calculations), and in developing the constants needed for implementing floating point subroutines that calculate special functions, perform numerical integration, evaluate functional transformations, and similar tasks.
Over the previous two years, the SQLite development team has used hundreds of micro-optimizations to reduce by half the number of CPU cycles needed to perform common operations. We speculate that the same optimization techniques can be used to extract similar performance gains from TCL.
This talk provides an overview of the optimization strategy used by SQLite. An optimization workflow checklist will be shown, with details on the prerequisites and tool-chain requirements for doing micro-optimizations of complex C programs. Numerious specific examples of small changes to the C code that make a measurable performance difference will be displayed and analyzed.
With the advent of TclOO, the Tcl community is in need of common design patterns on which to build applications and utilities. Rather then descend into a myriad of domain specific libraries, this paper presents the concept of a TOOL (Tcl Object Oriented Library). Borrowing many of the conventions and idioms from Tcllib, the goal of TOOL is provide a common suite of tools that are tested, documented, and ready for immediate deployment. Like Tcllib, TOOL will be broken into modules by subject area. This paper will focus on the core classes as well as NetTOOL (a library for network protocol development), WebTOOL (a library for web applications), and TOOLShed (a suite for building and distributing script and binary packages for Tcl.)
A case study for mixins in adaptive widgets
Displaying file contents is a long-understood problem with many solutions, the obvious one being to load the file into a text widget and attach a scrollbar.
It gets trickier when you nee
1) The file may change size. 2) The file may become larger than machine memory. 3) The file may be compressed. 4) The file may become compressed.
The TclOO mixin construct lets us construct a widget that reacts to the changes in the file being displayed by modifying the read and display properties.
A fileWatch widget that reconfigures its behavior as the file changes will be described.
This presention intends to provide an overview of (various aspects of) Tcllib. From where it began to where it is today, be it location, content, or the tips and tricks a developer should know, be it user, or maintainer.
Rosea is a Tcl package that implements a data and execution domain that is suitable as the target platform for translating executable software models into programs using Tcl as the implementation language. Translation is accomplished by capturing the characteristics of the software model using a domain specific language from which the data structures used by the run time component are built. This paper presents the design and implementation of rosea showing how Executable UML model semantics are mapped to Tcl language constructs. Model classes are held in relation variables and class relationships are enforced as referential integrity constraints between the relation variables. Dynamics are implemented as Moore type finite state machines. Processing is event driven and transactional in nature with the state of the program data being rolled back if integrity checks fail.
Regression GUI testing.
GUI testing is commonly done manually, with a trained tester clicking buttons and confirming events.
This is time consuming and expensive. It can be done before a product is released, but is too human-intensive for anything but targetted changes during development.
The TkTest package described at the 2004 Tcl/Tk Conference solves many of the testing problems by automating the GUI events and using Tcl's introspection to confirm that the events had the expected effects.
This tool is useful for a single developer, but the tests must still be run manually and observed.
RTDA has many developer's working on the Tcl/Tk GUI engine. They have an automated system to perform nightly builds and regression tests.
This need to do automated GUI testing drove the need to expand TkTest.
TkTest was expanded to be run from a command line and generate reports. To make the reports more useful, new tools were developed to report inconsistencies in complex GUI displays and to reject irrelevant inconsistencies.
This talk presents work in progress on compilation of Tcl to native code via a novel intermediate language, quadcode, and LLVM IR. It discusses some of the details of how we analyse Tcl in order to make useful type assertions, the strategy for issuing IR and native code, and presents some of the early performance results,which are believed to be of great interest.
We present Swift/T, a novel programming language for extreme-scale supercomputers, that compiles into Tcl code for execution on a runtime based on Tcl and MPI. The Swift/T language enables users to rapidly compose Tcl fragments, including Tcl extension functions implemented in native code, into a massively scalable program capable of utilizing petaflop-scale computers. Swift/T has a growing user community in multiple scientific computing domains, including materials science, proteomics, and epidemiology. This paper summarizes the use of Swift/T for Tcl users, its performance achievements, and some early use cases.
This talk will look be a musing of what Tcl could have been (or in some case could be) if slightly different decisions had been made. Things such as "popularity", GUI, data structures, syntax and acceptance. Some comparisons will be made to other languages -- although not those you likely expect.
Note: This will be a presentation only -- no formal paper will be submitted.
Roasting the TCT, as is present
TyCL (Typed Command Language) is a compiler/interpreter inspired by Tcl's syntax. This last version marks the stabilization of its internal architecture by providing a new infrastructure for the type-system and the WordCode generator. This paper presents an overview of TyCL's official features and capabilities, including execution-performance and memory-usage.
In today's world of constant hacker and security threats, the Tcl VFS Interface provides a mechanism whereby Tcl scripted applications that are previously unaware of security and encryption concerns can transparently access both data files and Tcl modules from an encrypted container file without modifying the application specific file accesses. This mechanism allows data residing on disc to be strongly encrypted while it can be transparently accessed from a Tcl application that has the appropriate decryption keys to access the data transparently through normal Tcl file accesses. We examine CalVFS, an implementation that allows users of Mentor Graphic's Calibre electronic circuit verification tool to encrypt sensitive user information in such a way that it can be transparently accessed by the Calibre application.
There are a plethora of (proposed) standards and proprietary solutions for the Internet-of-Things: from protocols, to data modelling, and abstractions. Integrating applications struggle to move data between these silos. Biot implements a generic network-aware information pipe to move data from anywhere to anywhere: from devices to the cloud (sensing), from the cloud to devices (actuating) but also between clouds (integration). Biot is tuned to be embedded in modern cloud architectures based on micro-services and has been deployed within CoreOS and Docker Swarm clusters.