Crowne Plaza Houston River Oaks Houston, Texas, USA 2712 Southwest Freeway, 77098 Phone: 1-713-5238448 Fax: 1-713-5771273
A review of the major events in Tcl / Tk development and releases since the last U.S. conference.
Writing a killer-app is the easy part. The next stages include complete testing, user acceptance, marketing, sales, manging the users and more. A product needs a website that drives sales, tutorial videos, promotion, visibility,
This paper describes how Editomat is solving (and not solving) some of these problems as it matures from a quick and dirty Tcl application into a viable commercial product.
This paper describes how we have used JSON, XML, CSV for interfacing between various software sub-systems.
FlightXML is a tcl implementation of a SOAP/REST API for accessing FlightAware's data. The first version, DirectFlight used the SOAP::Domain and SOAP:wsdl packages to build its SOAP interface. In subsequent versions we have migrated to tclws to provide the API interface. During FlightXML2 development, tclws was extended to provide a REST interface using yajltcl to build the json responses. For FlightXML3, tclws was enhanced with an optional operator to be used when constructing the response/request data types and optional strict parameter enforcement. Further enhancement included an error callback handler. These updates are available publicly with tclws v2.4+.
possible full-hour slot
The last several years have been an active time in the research and development of efficient, immutable, functional data structures. It?s too late to talk of this work as "new", but it is newer than the Tcl codebase, and than most of the techniques found within it. Since Tcl values are themselves immutable and since Tcl has enough of a Lisp character to profit from functional programming foundations, it makes some sense to examine how these "new" developments can be exploited by Tcl.
Many of the successful data structures in this area have been built up out of the building block of the Hash Array-Mapped Trie (HAMT). In this presentation, we examine the HAMT by way of seeing how it can reproduce the key-value mapping function that Tcl achieves with hash tables. Working through this concrete application aids in understanding some of the complexity found in the HAMT. The implemented HAMT can then be used as the foundation of revised internals of Tcl?s dict value, allowing us to examine the immediate pros and cons of the data structure, and speculate about others on a firmer foundation.
Odielib is a collection of tools and C accelerated math functions that I have collected over time, and repackaged in a variety of ways for several projects. The most interesting parts of odielib for most users will be the 3d vector arithmetic and transformation functions, which are implemented as a custom TclObj type. This paper will describe some of the complexities of implementing custom TclObjs, as well as novel strategies used by this library for managing how data structures interact with the interpreter.
This panel will cover the future of Critcl, TEA, and Tcl based Build systems. Why are binary Tcl extensions so hard to make and maintain? What can we do to make it better?
Present a roadmap for getting ZipFS in the core. Preview the build tools that will be available in TEA for assembling kits. Sort out what build facilities will need to be part of TEA to facilitate embedding binary extensions in static applications.
Tcl provides excellent support for creating complicated user commands in applications that have correct-by-construction built-in help, support for hidden commands, support for position-independent switches, and more. This paper discusses the technical details for how we created one such command in our Qt-based application.
SQLite is the most widely used database engine in the world. There are more instances of SQLite running than there are instances of Linux, or Windows. There are more SQLites than there are iPhones. SQLite is one of the most widely used software components in the world. And one of the best kept secrets of SQLite is that it is a Tcl extension that escaped into the wild. Thought no Tcl code is build into SQLite, Tcl is required in order to build SQLite from canonical sources, and Tcl and Tk are integral parts of all our development processes.
State Of FlightAware Bounties
The tclquadcode system is a compiler, now under development for
about three years, that translates a significant subset of Tcl to
machine code. For the limited cases that it can handle, tclquadcode
produces significant gains with respect to the bytecode engine:
3-6-fold speedup in the typical case, and 30-100-fold speedup in the
most advantageous cases. This talk presents recent work on speeding up
the interface between compiled and interpreted code, avoiding memory
allocation, and supporting non-local variable references. The speakers
also intend to poll the audience informally on several topics where
quadcode may drive developments in core Tcl.
possible full-hour slot
possible full-hour slot
Present the tools available in Vectcl, Odielib, and Tcl3d. Sort out how to take 3 semi-working extensions and turn them into one comprehensive framework.
The essential idea is to add a cache to Tcl?NewStringObj in the core so that it returns references to recently and commonly used values instead of creating new string objects. There are obviously complications to this approach, and it triggers issues with sloppy refcount management, assumptions about the TclIsShared state of the returned objects, and (very rarely) assumptions about the type of the objects returned. To work around these I hacked up an automated system to find a safe subset of Tcl_?NewStringObj calls in the core to replace with versions that include the cache, and still allow some subset of the test suite to pass.
The (very early) indications are much more encouraging than I expected (the following measured with [time] in an interactive tclsh, both built with -O2, time in microseconds / iteration):
24th Annual Tcl/Tk Conference Vanilla 8.6.7 Dedup 8.6.7 Factor
info commands 7.85853 3.84669 0.489 clock microseconds 0.38309 0.27893 0.728 clock format [clock seconds] 8.1333 6.57341 0.808 glob /usr/lib/* 281.9676 273.2906 0.969
proc foo {} bar; proc bar {} {error bang} catch {foo} 6.118 4.83416 0.790
These results were obtained with only about 20% of the core's calls to Tcl_?NewStringObj replaced with caching versions, the subset found by the automated tool when considering the code exercised by 'make test TESTFLAGS="-match clock-*"'. There are a few that are disabled from that set that would have an additional impact, but which would need some changes to the reference count handling (part1Ptr and part2Ptr in tclVar.c, etc), and many others that are outside of the code searched by the automated tool for that test.
The core of the cache is the value deduplication mechanism from rljson, so I know it's solid (seen extensive production use for more than a year now), and there is no technical reason preventing every Tcl?NewStringObj call from being converted, in the core or extensions, once the refcounting issues are resolved. There should also be a significant reduction in peak memory usage for most common workloads, but I don't have the numbers to back that up yet.
This talk provides an overview of the state of Fossil, the DVCS used to manage the Tcl/Tk sources.
Translating Executable Software Models with micca Tcl Applied to Formal Software Methods
Andrew Mangogna
amangogna@modelrealization.com
Abstract
Micca is a program, written in Tcl, for translating executable software models into "C" code. It accepts a domain specific language formulated as a Tcl script that describes the data, dynamics and processing for a software domain and produces "C" header and code files implementing the model logic. This paper explores the underlying Tcl technology that is used to implement the translation. Tcl features and extensions for creating DSL's, handling relational-structured data, parsing using a PEG and code generation using template expansion are discussed. The source code for micca is freely available and licensed in the same manner as Tcl.
This will discuss the addition of a framework to the tcltest package to make unit testing of tcl code easier. The framework is proposed in TIP 452. Both standard procedural and tcloo based tcl code is supported.
Missing abstract
tclrmq: A pure Tcl library for RabbitMQtclrmq is a fully asynchronous non-blocking pure Tcl library for
working with AMQP v0.9.1 and RabbitMQ. Using TclOO and
event-loop registered callbacks, it provides a natural Tcl interface
for the most widely deployed open-source message broker. Unlike a Tcl
extension for accomplishing the same task, tclrmq requires no
external depencies outside of Tcl 8.6. Complete implementation of
RabbitMQ specific features included, such as TLS support, publisher
confirms, consumer cancel and blocked connection notifications, and
negative acknowledgments. This presentation will introduce the library
and detail how best to use it.
My proposed talk on tclrmq is meant to be a quick introduction to
distributed messaging through the lens of a soon-to-be-released Tcl
library. It is intended mainly for those who have only heard of, but
not programmatically used, this well known application messaging
protocol. By exhibiting how best to work with the library, my
presentation will illustrate how to create distributed messaging
applications with only a few lines of Tcl. Leveraging the event loop
and a callback based style, tclrmq provides a natural interface for
communicating with the RabbitMQ AMQP v0.9.1 broker. In addition, the
talk will also be of help to those more familiar with the topic by
making available at the time of the talk full library documentation
and many ready-to-use code examples which can be used as templates for
making immediate use of the API. It is meant to spread the word about
a newly available ability to use Tcl with one of the open source
community's most stable, widely used server technologies.
Postgresql has a mechanism for dumping WAL changes in any streaming format. Technically, anyay... the only sample format they provide is a rather chatty human-readable one that?s completely useless for software.
By building an extension for the pgtcl postgres interface library to quickly copy the initial state of the postgresql database to SQLite, and then using a postgresql output extension to stream database changes in an easily parsed tab-separate key-value pair format, we will be able to copy postgresql tables to a local SQLite "cache" and then use the stream of changes to keep them up to date. Duplicating the SQLite variable substitution code in pltcl we will be able to make complex queries from tcl against postgresql or SQLite transparently.
The socketservertcl Tcl extension implements SCM_RIGHTS passing of accepted sockets between processes. Each process receiving a socket from the accepting server can handle the I/O in parallel. The extension supports worker pre- forking. The worker uses the standard Tcl socket patterns. Worker accept connections with a callback. The worker receives a connection for each callback registration. On completion of work, the worker re-registers for the next available connection. The workers wait on a pipe for sockets from an accepting server. The exchange of a connection between the server and worker is on a UNIX pipe. This exchange is performant.