Technical Session Abstracts
With a background in programming, Colin Walker somehow ended up working for a networking company, and has never looked back. Having joined F5 Networks in December of 2004, he quickly fell in line with the application aware scripting capabilities (iRules) that help make F5 devices as flexible as they are. As an iRules zealot Colin works to further the technology, guide Product Development on potential roadmap decisions and evangelize to the community and, frankly, anyone that will listen about how you can use the power of the network to better applications everywhere.
Starting first in Unix (BSDi/FreeBSD) technical support for a shared web hosting company and working up through sys-admin and eventual to software engineer, Colin has been steeped in applications and automation but also in the importance of making good on commitments to end users, implied or otherwise for nearly 15 years now. Approaching every project, whether it be deployment design, application troubleshooting, network optimization or the like, he does so with a mind towards the end goal: delivering applications to users as effectively and efficiently as possible.
The context manager is aimed at being the hub of the house, a place where all sensors report (directly or indirectly) their data, sometimes in aggregated form, but also where all applications will search for information relevant to them, i.e. sensor values, location or information about their surroundings. The context is instantiated from a dynamic model to fit the needs of a variety of scenarios and settings. The manager provides an easy-to-use Web API and integrates external cloud services relevant for applications running in the house.
The paper documents the history, design, and philosophy of Wibble; demonstrates its use for simple, complex, interactive, collaborative, and database-driven applications; and discusses its current limitations and future development plans.
This paper proposes a new programming language similar in structure to Tcl. The new language embeds several functional programming concepts which are currently awkward or difficult to realize in Tcl. A reference system serves as the foundation for several other new features. The Tcl object model is refined to address performance concerns encountered in the Wibble project. Syntax is fine-tuned to streamline preferred usage. Despite similarity to Tcl, backwards compatibility is broken. The paper discusses the motivation, design, and semantics of the language and provides a preliminary specification. Included code samples contrast how various tasks are done in Tcl and the new language.
The Representational State Transfer (REST) architecture includes the use of Uniform Resource Locators (URLs) to place a universe of data into a single namespace; the use of URL links within the data to allow applications and users to navigate the universe of data; HTML/CSS for the presentation of data; a limited set of operations that are available for all URLs; multiple content types, and content negotiation when retrieving data from a URL. REST is primarily used in web applications; however, purely desktop applications can also benefit from RESTful concepts and technologies, and especially from the integration of web-like technologies with classic application software. This paper describes how REST concepts and technology have been used in the Athena simulation to present a vast sea of heterogeneous data to the user.
This paper describes a package enabling Tcl scripts to talk to Kinect and related devices.
While KineTcl is technically a binding to the OpenNI framework, thus providing access to all depth sensor devices with a plugin for it, the most kown device so far in that category is MS' Kinect.
The paper will describe the internal structure of the package, how it matches to the OpenNI API, and how to weave both C and Tcl together to make use of each others strengths. Beyond that it will point to supporting packages and tools used in the implementation (mainly critcl and helper packages for higher level code generation).
I wish to present a paper this year on a design concept I call "Lifecycle Object Generators", or LOG for short. It involves a combination of coroutines, TclOO, and basic data structures to create objects that can readily transition from one class to another throughout the course of an application. In this paper I will describe the basic mechanisms required, and how this architecture can be applied to any complex problem from GUI design to Artificial Intelligence.
At the 12th annual Tcl/Tk conference in Portland, Oregon, I presented a paper entitled 'Pulling Out All the Stops' - which concerned using Tcl as a user interface custom calculation engine at the heart of a high performance electronic design analysis package. This talk discussed the efficiency concerns and implementation details that were considered during implementation of this package. One simplifying constraint applied to the design was that, though this is a multi threaded application, a single Tcl interpreter was used and individual threads would access that Tcl interpreter through a mutex lock. seven years later, customers are running more complex calculation codes on systems with more processors. Locking on the single Tcl interpreter now restricts scaling. This paper briefly reviews the original design and then discusses the conversion to a fully threaded design in which one Tcl interpreter per thread allows completely parallel execution of the Tcl calculator.
In Mentor Graphics' Calibre verification tool, Tcl is frequently used as a customer extension language - allowing customers to customize and drive the tool through various exposed interfaces. These interfaces are frequently used to access large collections of data and provide a wide variety of mechanisms for iteration over that data. This paper will examine several interfaces that have been used for iteration over large C++ datastructures along with the benefits and drawbacks of each method. Methods explored include Tcl lists, indexed array-like access, iterator object accessor (similar to C++ STL iterators), and specialized foreach style commands. Example stand alone implementations are provided and discussed from within the context of their original use in Calibre customer scripting interfaces. Ease of use and performance are considered.
TyCL is a implementation of Tcl oriented towards the creation of machine-code executables besides being just an interpreter. In order to reach this goal, a series of modifications had to be made to Tcl's syntax and functionality, which creates some distinctions in its usage. This paper describes the current state of TyCL and highlights the similarities and differences between them, alongside the new features that TyCL provides.
One of the most desired/used parts of Tcl/Tk is the Tk component, probably because it's compact, easy to use and, of course, cross-platform. In consequence, if TyCL wants to be as close to Tcl as possible, it has to provide something similar to Tcl's Tk. TyCL/GK (where GK stands for GUI-Kit) is a layer on top of TyCL that provides a set of objects and functions that allows the creation of GUI elements by exposing an unified GUI-API model at the developers point of view and providing whatever is necessary to the operating system's libraries (which are the ones that do the real work) to maintain such unified model.
The largest part of a database project is frequently building custom edit screens for all the tables.
This widget set uses Tcl's ability to extract a schema from the database to build "useable" entry screens with no additional programmatic input.
With extra comments in the SQL Schema or a modified display schema, it can build a GUI with proper formatting and field labels that make sense.
With another set of config options, it creates a custom GUI that does not exactly reflect the underlying database schema.
Proficient use of a software tool only happens after working with the tool for an extended period of time. The user must become fluent with the tool.s functions, the toolbars and menus, which commands are best for a specific task. Many users want to take their proficiency to a higher level. Often called a .power user., the aim is efficiency and speed in order to get the job done quickly. Navigating through a sequence of menu picks to access a commonly used operation can be time consuming. Repetition of the same task requires the user to traverse the same menu path every time that task needs to be performed. User interfaces try to address this issue by adding toolbar buttons, but GUI based buttons still require a number of steps to execute a command. Keyboard shortcuts are the fastest and most efficient way to work.
A keyboard shortcut refers to pressing a specific sequence of keys to execute an operation. Most programs or software tools have a predefined set of keyboard shortcuts. However, a tool that has dozens of windows, hundreds of operations, and runs on multiple platforms cannot define a set of shortcuts that meet the needs of all users, especially the power user.
Modelsim is written in Tcl/Tk and was recently enhanced to support user defined keyboard shortcuts. Users can associate a key sequence with a menu pick, a toolbar button, a CLI command, or a custom tcl script. In addition, the new functionality is flexible, allowing the user to make the key sequence universally available or assign it to a specific window. Several technical challenges were encountered when implementing this new functionality. Tcl/Tk has a unique methodology for processing keyboard events and the solution required an architecture that functions within the bounds of this methodology. This paper will discuss the basic Tcl/Tk architecture that was implemented as well as the technical challenges and their solutions.
Roshni Lalwani, Amarpal Singh
This paper presents a novel method of how enhanced TCL/TK widgets can helps users in debugging various design issues of EDA tools.
A callout box and a novel dialog box to display/edit the text ,that helps user to debug various design issues.
Manu Goel, Antara Ghosh, Sachin Kakkar
Debugging a design in EDA has always been challenging and is a time consuming process. Designers need to have access to an efficient tool which can provide them the design connectivity in a logical and efficient manner. This paper discusses about various challenges for writing such a tool for debugging a design and how were they handled to provide a fast and efficient tool. Schematic browser is a Tcl/Tk based GUI application, which user can use interactively to debug/understand the design.