| Home | 2009 Ideas >>> |
A part of Google Summer of Code.
This is the central location for proposing ideas for the Summer of Code [L1 ].
A mailing list (tcl-soc2008 at lists.sourceforge.net) has been created for discussions of project ideas and other conversations about Tcl/Tk SoC. Students, Mentors, Potential Students, and Potential Mentors should join. Details are available at https://lists.sourceforge.net/lists/listinfo/tcl-soc2008 .
The 2008 Tcl/Tk SoC Coordinator is Matthew Burke (mmburke monkey-paw gwu full-stop edu). Contact him if you have any questions.
If you are a student interested in getting paid to develop open source software using Tcl/Tk, we encourage you to apply.
Why should you want to do this? Tcl/Tk is perhaps the most mature of the dynamic languages, dating back to 1988. The evolution of the language over the last 20 years has been marked by passionate preservation of the balance between maintaining simplicity and utility with the adoption of new ideas and new techniques based on accumulated experience.
Tcl/Tk is used in a number of prominent software systems including DejaGnu (e.g. used for testing the gcc compiler), Expect and AOLserver. The language is used by many scientific organizations including NASA as well as being used extensively in the commerical and financial sectors.
Please see Google's SoC FAQ [L2 ] for more information on the program. There are several good sources of advice for choosing a project to which you should apply [L3 ], expectations of student participants [L4 ], how to write a compelling application [L5 ], and proposing your own project [L6 ].
Any project completed before the Fifteenth Annual Tcl/Tk Conference (2008) will be accepted for presentation in the conference Technical Track.
If you have an idea, please include it in the list below. Put "MENTOR REQUIRED" in the mentor line if you are unable to serve as mentor for the project. Contact Matthew Burke (see above) with any questions.
Also see the Organization Application for Google Summer of Code 2008.
Also see http://code.google.com/soc/2008/tcl/about.html
The tcllib package provides functionality for creating and manipulating graph data structures in Tcl/Tk [L7 ]. Although the package is fairly flexible (e.g. allows attaching arbitrary attributes to graphs, arcs, and nodes), there are a number of useful functions that could be added such as finding connected components, determine (shortest) path between two nodes, etc. Integration with Nauty [L8 ] is another desirable feature.
Gain experience in writing language extensions. Learn some graph theory.
More powerful graph handling capabilities.
The Tk test system still uses primarily tcltest v1, and would benefit from an update to tcltest v2 and a full reexamination of out-dated tests (based on specific font characteristics, etc.).
Gain experience in developing language extensions. Learn about testing frameworks.
Improved testing capabilities.
Tcl's support for loading shared libraries from virtual filesystems consists of copying the file in question out of the virtual filesytem to a temp file on disk and having the operating system load that.
This project seeks to avoid the clutter of temp files to allow Tcl to directly load shared libraries from memory (or a Tcl channel). Implementations are needed for Win32 (DOS/PE) and Unix (ELF) (MacOS X already supports this, c.f. below).
Main use case: single-file deployment (starpacks, freewrap). Also: Use by Tcl/Tk Tclet Plugin and other high-security environments where an app is not allowed to write to an actual disk.
A real-world scale project leading to understanding of file and memory handling on multiple platforms
Adds a feature that will enhance the Tcl language and all applications using Tcl/Tk.
Note: Tcl on MacOS X (since 8.4.10) does already support loading shared libraries from memory - so this proposal would bring other platforms into line.
DAS: Specifically, the generic support code for this is #ifdef'd by TCL_LOAD_FROM_MEMORY and the MacOS X-specific implementation is contained in tcl/unix/tclLoadDyld.c, see [L9 ] for the patch.
Tcl has a DTrace provider since 8.4.16/8.5b1, but no binding to the DTrace API (à la ruby-dtrace [L10 ]) exists yet. Such a binding would allow the writing of D scripts in Tcl to trace the system and/or Tcl itself, and the processing of trace results directly in Tcl. Among other things, this would present very interesting opportunities for debugging and profiling Tcl scripts from inside Tcl.
Experience with C, basic experience with (and access to) Solaris 10 and/or MacOS X Leopard, familiarity with Tcl C API or with DTrace a plus.
Gain experience with C, Tcl C API and DTrace internals.
Very interesting tool for debugging and profiling Tcl scripts, as well as for scripting DTrace in general.
http://bluedino.net/nsgd/ http://dev.lrem.net/tclgdaol
AOLserver [L11 ] is an open source web and application server that uses Tcl as its scripting language. Nsgd is a module for AOLserver that allows a web designer to create dynamically-created graphics using the GD library [L12 ]. The first version of the module [L13 ] is difficult to configure and build, has a byzantine API, cannot share generated graphics among server threads, and does not take advantage of several functions in the current version of GD.
The second version [L14 ] has an improved build process and fixes several bugs. However, it does not address the other problems found in version 1, particularly the inability to share graphics across server threads. The current version [L15 ] is a start at rationalizing the API.
There are a number of possible tasks for a student interested in improving this software. Depending on the skills and interests of a student, this could be split into projects for more than one student. The tasks include the following:
A polished version of Nsgd will provide a powerful and flexible tool for creating web services for dynamic graphics.
NO URL
Tk has supported exporting a canvas to a Postscript File for a long time. The Img extension allows a screen image to be converted into an image object. There are several partially complete PDF generators in pure Tcl, and a few tools to export a canvas to PDF. There is no way to send data to a printer on MS Windows. There is no print facility for a text window. There is no export facility for windows other than the canvas.
The project will be to unify these unconnected pieces and make a coherent printing system for Tcl/Tk that allows
This has been in the top 10 list of things that industrial users want for over 15 years. The code will be put into active use as soon as it's available.
The student will gain real-world experience with extracting a coherent set of specifications from a disparate set of requirements. The project can be partitioned into phases that become larger and more difficult as the project progresses. The student will gain familiarity with the PDF language, as well as Tcl and C. The student will have the opportunity to work physically in a rapid-prototyping environment and see their code go into products as soon as it's ready.
See: fuse, http://fuse.sourceforge.net
Produce a fully-functional Tcl language binding to FUSE virtual filesystem kernel module, making it possible to create filesystems using Tcl that can be seen by all processes. Ensure the binding works on all or most operating systems supported by FUSE.
Learn about operating system architecture and administration, kernel modules, virtual filesystems, comparative operation of different OS platforms.
A Tcl FUSE language binding would leverage two of Tcl's strongest features: its cross-platform capability, and extensibility as demonstrated by the TclVFS package. This binding would make it possible to write a single virtual filesystem in Tcl that ran on multiple platforms, thus allowing quick development of many useful solutions for archiving, backup, content management and communication.
http://www.xotcl.org/
Business Rule engines are gaining popularity in complex situations where a high degree of flexibility and declarative problem formulation are important. High level object oriented scripting languages are as well gaining popularity especially in the area of Web programming. Extended Object Tcl (XOTcl) is one of the most flexible languages of this kind, especially through its highly flexible composition techniques based on mixin classes. The language was originally developed for providing language support for the dynamic use of design patterns.
The core part of this project is an implementation of Charles Forgy's Rete algorithm in XOTcl. The Rete Algorithm is an efficient method for comparing a large collection of patterns to a large collection of objects. It can be used to find all the objects that match specified patterns. The algorithm was developed for use in production system interpreters, and it has been used for systems containing from a few hundred to more than a thousand patterns and objects. It is used in a number of popular systems, as CLIPS or JBoss Rules/Drools for example.
This project includes a high performance implementation of the Rete algorithm and an a study, how to use it in combination with the dynamic language features of the base language to define a reusable, flexible, and easy to use system.
Gain experiences in dynamic object-oriented programming, pattern-matching and business rules
A reusable package for the implementation of highly flexible and efficient business rule systems, which can be embedded in various environments.
aMSN is a Tcl/Tk Instant Messaging client working on the MSN network. We try to provide as much of the original client's functionality in aMSN.
One of the most requested features is to have the ability to do audio conferencing, while the protocol and codecs have already been reverse-engineered, we are stuck now on a limitation of Tcl. There is no acceptable audio output/input extension for Tcl. The only extension available with enough capabilities to satisfy us is the Snack extension which is unmaintained for too long now and has many small issues and limitations which makes real-time audio processing impossible (device is opened/closed on every packet (20ms) and audio is played too fast, so it keeps glitching, etc..).
A solution was found in the libao library [L17 ] which did the trick for audio output and worked nicely on Linux, but it only has a winMM driver for Windows which doesn't seem to work. An alternative is libao2 which is a fork of libao by the mplayer developers, it is much more complete (has many more drivers and has a dsound driver for Windows), but its API is not very usable and its code is dependant on mplayer's internal libraries.
This project will consist in merging libao's interface [L18 ] with libao2's drivers [L19 ] and make it into a single, standalone library, as well as creating an audio input equivalent and writing a Tcl extension to wrap the library, thus providing the Tcl community with a new, more powerful audio input and audio output library. This will allow the creation of new real-time audio processing Tcl applications.
A secondary purpose of this project would be to continuously discuss the changes with the mplayer developers in order to have them integrate the new library and to avoid having a third (or more) fork of libao.
Experience in Tcl, alsa, oss, arts, esd, pulseaudio, jack, winmm, dsound, CoreAudio, etc..
Having a more mature Tcl extension for audio processing will be a great addition to Tcl as it will open up a new field for application developers. The advantage of using such a library would be the possibility to write applications that play or record audio in real-time, thus allowing the possibility to build VoIP applications in Tcl.
Also, this driver-based library will allow Tcl applications to play and record audio using either alsa, oss, arts, esd, pulseaudio, jack, directX, CoreAudio, etc.. and to integrate with those sound daemons using a single, unified API.
Having such a powerful library will also bring a great advantage to the Open Source Community as it will provide application developers of any language to use a much more stable 'libao' alternative without forking the mplayer internal library.
[DKF: these need cleaning up and sorting]
Drawing together mixed implementations that are available, this would require a student with an interest in protocols and a good eye for compliance and discipline for test-driven development.
Gain experience in developing language extensions, develop deeper understanding of HTTP.
More consistent and powerful functionality for manipulating HTTP requests and responses in Tcl/Tk scripts.
Based on the soon-to-be-core TclOO extension, translate and update the plethora of megawidgets into a single, unified megawidget system that can be "core" blessed. Would involve extensive use of OO, x-platform UI, event-driven coding, etc.
Practical experience in design and implementation of a widget framework.
A consistent widget system making use of new core functionality.
The goal for this project is to develop an AOLserver module which enables the server to generate instant messages in response to HTTP requests and to evaluate resource scripts in response to instant messages. An easy approach would be to create a separate thread which monitors two queues: one for incoming instant messages and one for responses to be sent out as instant messages. A more comprehensive approach would be to develop a request handling framework for instant messages that works like AOLserver's other protocol handlers.
Information on libpurple can be found at [L20 ].
Learn about AOLserver internals, multi-threaded programming, instant message protocols.
Allow application developers to easily adapt their services to communicate with users over additional channels with minimal duplication of effort.
Firefox has recently been extended to permit scripts in languages other than JavaScript to appear in <script> and to evaluate them. These scripts provide access to the DOM. Production of an XPI installable module which links FireFox scripting to a Tcl interpreter would be a beneficial project. Addition and rehabilitation of the tcl xpcom interface package would complete the package.
Two levels - Tcl and Firefox. Firefox level hacking is a commercially valuable skill. FF community has a lot of hot C/C++ people. Firefox has a long future. Tcl is great :) Putting the two together could spark a lot of activity.
Web applications have a great future - shame about the JavaScript. I think the ability to manipulate the DOM from Tcl would immediately enable a wide range of applications due to Tcl's greater maturity and facility compared to JavaScript. This would benefit Tcl by increasing exposure (it would bear the same relationship to Tcl as Tk does, but in a whole new field.) I daresay it might also benefit the broader community, by bringing Tcl into this field.
TclScript would provide the ability to run Tcl scripts in Internet Explorer similar to the above project's goal of scripting in Firefox. See [L21 ] for more info. The ability to run Tcl scripts in both IE and Firefox would be very advantageous (Tcl is suddenly a powerful web client development platform), and each of these two projects would make the other more valuable.
Recent reports [L22 ] highlight the popularity of enabling different languages to run in a JavaScript VM within a web browser. The referenced article mentions Ruby and Java. An equivalent program for running Tcl Scripts in JavaScript would provide a zero-install fallback for the above two projects.
Possible approaches:
http://plugin.tcl.tk/
The current Tcl plugin is based on security policies that are configurable via special configuration files on the local system. These may be extended, but only what is named and known at runtime is available. A tclet (Tcl plugin application) can request a certain security level and is only given access if the local configuration expressly allows it. A user is not allowed to "opt-in" some tclets. More information on the current design is at:
https://www.tcl-lang.org/software/plugin/safetcl.html
https://www.tcl-lang.org/software/plugin/man/pluginDoc/policy.htmThis project seeks to revamp the security policy management in the Tcl plugin to allow for UI-level control of security policies, as well as dynamic control for elevation/restriction of security based on domain and/or URL.
Gain experience in web based security and secure coding practices.
Improved plugin for web applications.
The current Tcl plugin had a Mac Classic port and works on Win32 and X11 systems. It currently lacks a functional native Aqua port. This project seeks to provide a native Aqua port of the Tcl plugin. Knowledge of Tk and native OS X APIs would make this easier.
Gain experience in web plugins and OS X.
Complete set of "common" platform ports for Tcl plugin.
http://tktable.sourceforge.net/tile/
Tk 8.5 supports themed widgets. On Windows and MacOS X the theme engine calls the native APIs to draw widget elements and achieve a native look. On X Window System desktops however Tk uses its own drawing code. There is a theme using Qt for KDE integration but nothing that permits integration on a Gtk desktop. Some initial experimentation by Pat Thoyts shows that it is at least possible to have the Gtk style engine draw Tk theme elements.
Experience with Gtk and Tk libraries.
Significantly improved integration of Tk applications on Gtk-based desktops (e.g. Ubuntu, Fedora)
http://sourceforge.net/projects/tktoolkit
The current implementation of the native MacOS X Tk is based on the legacy Carbon/HIToolbox API. Large parts of this API are deprecated with Leopard and not available to 64bit applications. This project aims to replace Tk's use of HIToolbox with Cocoa/AppKit. In a first instance, window (toplevel) creation and management would be targeted, with other areas like widget creation or event handling to follow if time permits.
http://developer.apple.com/cocoa/ http://developer.apple.com/documentation/Cocoa/Conceptual/WinPanel/WinPanel.html http://rutherglen.ics.mq.edu.au/fisheye/browse/Tk/tk/macosx http://rutherglen.ics.mq.edu.au/fisheye/browse/Tk/tk/macosx/tkMacOSXWm.c?r=HEAD
Experience with C and Objective-C, in-depth familiarity with Cocoa frameworks, familiarity with Carbon and X11 APIs a plus.
Gain experience with the use of Cocoa in an unfamiliar and challenging environment, learn about lower-level details of the MacOS X frameworks.
Assure Tk's future on MacOS X by moving away from deprecated APIs in the Tk implementation.
J. Todd Slack is now working on this. Please see the discussions on the tcl-mac mailing list [L23 ], [L24 ] for details.
http://sourceforge.net/projects/blt https://wiki.tcl-lang.org/199
BLT is one of the most delightfully useful Tcl/Tk extensions. It provides an extremely efficient implementation of floating point vectors, which greatly enhance Tcl's ability to do number crunching. And the graph widget enables rapid development of analysis scripts that are highly functional and very fast.
Unfortunately, BLT's origins predate many of the modern Tcl extension features, and because it is not TEA (Tcl Extension Architecture) compliant, it is challenging to update it for new language releases. Further, BLT is not ported to the Aqua environment on MacOS X.
This goal of this project is to refactor the vector and graph portions of BLT into a new, TEA compliant extension that runs on all major platforms, including Aqua. Some portions (i.e., bgexec) have already been extracted, and some portions (e.g., tabsets) are now available in other extensions. The new extension resulting from this development will be immediately functional with Tcl 8.5 and deployable in starkits as a standard extension.
Experience working with C - the lingua franca of system programming. BLT is a positively brilliant, well written, C extension.
Experience developing a comprehensive test suite using tcltest as the tool to support agile, test-driven development.
The BLT graph and vectors will be available to programmers and users wanting to upgrade to Tcl/Tk 8.5.
BLT will be easily deployable in starkits and starpacks.
BLT will have an opportunity to be considered for inclusion in distributions such as ActiveTcl.
http://www.talend.com/
Talend Open Studio [L25 ] is an open source integration suite based on the Eclipse platform [L26 ]. Talend is a graphical Extract, Transform, Load (ETL) editor with support for Perl and Java code generation. The open architecture of Talend makes it extensible regarding new editors and ELT-components [L27 ]. The Eclipse Dynamic Languages Toolkit (DLTK)[L28 ] provides a TCL development environment ready to use out of the box which could serve as the basis to provide TCL support to Talend.
There are two possible tasks for a student interested in this project depending on the skills and interests. The tasks include the following:
Integrate DLTK inside Talend and implement the interfaces for the Tcl code generation engine.
Provide Tcl ELT component counterparts to those available for Perl and Java.
Experience in Tcl, Java and templating languages (code generation).
Experience in platform and RCP programming.
Experience data mining and enterprise integration.
Providing Tcl support to Talend is a significant contribution to the Tcl community. It will provide Tcl developers all fully integrated and graphical development environment for data and system integration. Generated ETL jobs can be easily deployed on any operating system with Tcl support.
The learning management system .LRN [L29 ] is an open source platform based on the web application framework OpenACS [L30 ], AOLServer and Tcl. It supports the e-learning standards IEEE LOM, SCORM 1.2, IMS QTI 1.2.1 and IMS LD 1.0 and partially IMS Enterprise.
There are several ideas for a student interested in this project depending on the skills and interests. The tasks include the following and are all based on existing work:
Contact proposer directly for information about difficulty of specific tasks.
Experience in Tcl, Javascript, AJAX, DHTML, Scalable Vector Graphics.
Experience with e-learning standards.
Experience with an exiting web application platform
Providing full e-learning standard conformance and web based editor functionalities to .LRN will make the platform the leading open source learning management system in the web.
A constraint solver can be an effective way to support a more declarative programming style and to exploit parallelism. This project would investigate adding constraints to the Tcl core by implementing a constraint solver as a package and identifying the core modifications that would be necessary to support it. As a starting point, the mentors can provide a working one-way constraint implementation, a discussion of the likely core changes needed, and a pointer to a multi-way constraint algorithm that would be a good candidate for implementation [L31 ].
Experience in Tcl and C/C++, constraints, and parallel processing.
Providing a robust constraint solver that can be integrated into the Tcl core is a significant contribution to the Tcl community that will complement Tcl's existing strong support for thread-based multiprocessing.
https://wiki.tcl-lang.org/20889
Tcl/Tk toolkit with Tile (theming support) allows building cross-platform GUI with native look & feel for MS Windows, Linux & Mac OS X. Recent TIP #308: Tcl Database Connectivity (TDBC) proposes standard SQL database API for Tcl. Selection of high quality tabular widgets combined with excellent retrospection capabilities of Tcl allowing to effortlessly create (like in Ruby on Rails) editing forms, provides basis for a framework for building database applications and their user interface GUI. Unlike in popular RAD (ex. Borland Delphi) we would like to build GUI by generating code not visually - as this is a recommended way to create GUI with Tcl/Tk.
First step in this project is to gain real life experience in cross platform Tk/Tile development by building simple time tracker like gtimelog (used further to track project progress). Next step is an attempt to port to Tcl/Tk/Tile selected fragments of quite complex business application UI build with RAD. This process should lead to choosing appropriate widgets, showing how to use and glue them together with database API.
Mentioned commercial database application will be provided by a mentor, who has full access to its source code and its primary authors.
Experience with some kind of RAD, database bindings, good SQL knowledge, basic Tcl & Tk knowledge and high motivation. Being able to meet personally in the early stages of the project or communicate in polish is a big plus.
Getting to know Tcl/Tk toolkit with native widget support by Tile extension (integrated in Tk as ttk::* namespace commands).
Verification and consolidation of separate components needed to build very common kind of application.
http://tkdnd.sourceforge.net/
tkdnd is the drag & drop extension to Tk that works on Win32 (OLE) and X11 (Xdnd) systems. It requires an OS X (Aqua) port to complete the common Tk platform set. Finishing this would allow its full integration into the core Tk codebase. Completing this might require refactoring of the currently public API for tkdnd in the case where OS X APIs don't match other platforms. Knowledge of Tk and native OS X APIs would make this easier.
Gain experience with Tk and OS X.
Provide a reliable drag&drop extension for all platforms.
http://tcljava.sourceforge.net/
Jacl is an implementation of Tcl in Java. Jacl currently implements Tcl version 8.0, with some support for newer Tcl versions. This project aims to bring Jacl's implementation to at least Tcl 8.4 levels. Primary focus is implementing fileevent for sockets and pipes, modern regular expression processing (i.e., PCRE, ARE), and updating other commands for Tcl 8.4 compliance. Additional features from Tcl 8.5 may also be incorporated, including Tcl 8.5 commands and list-expansion syntax {*}.
Gain experience implementing a language system in Java; direct use of Java NIO and network programming; event-driven systems.
Jacl will be modernized to current Tcl versions so that scripts written in Tcl run unchanged in a Jacl interpreter.
http://tcljava.sourceforge.net/
TJC, the Tcl-to-Java Compiler, is a compiler for Jacl. It compiles Tcl source files into Java source, which is then compiled with an embedded Java compiler. This project seeks to optimize code generation and compile additional Tcl commands. Note that the TJC compiler is written primarily in Tcl, and generates Java source code.
Gain experience compiler implementation and optimization.
Jacl/TJC will be enhanced to run Tcl scripts faster in the Java environment.
The Open Scripting Architecture [L32 ] is an extendible mechanism for inter-application communication in Mac OS X. Although originally designed for Applescript, it is possible to support other languages and their are OSA implementations of Ruby [L33 ], Javascript [L34 ], Perl (supposedly).
This project entails writing a library to allow Tcl scripts to respond to OSA events.
The student will learn about developing FFI software, Mac OS X, and Tcl internals.
Better integration of Tcl scripts with OS X applications.
Lars H: Doesn't TclAE already provide this functionality?
Urk. Now you see what happens when you do a half-***ed search. Yes, it does. I'll leave this here though just in case it sparks some ideas for someone.--Matthew Burke
RLH Maybe a cocoa bridge like Perl, Ruby and Python are using?
Glade [L35 ] is a visual GUI authoring tool designed for creation of Gnome applications. It saves its designs in a simple XML-format file, which is read and rendered at runtime by the libglade library into actual GUI code. The goal of this project would be to produce a rendering script which reads a Glade XML format file and renders it into Tk script instead.
The Tcl/Tk community would thus get a quality, maintained, cross-platform visual GUI authoring tool for free.
A Glade-to-gridplus translator might be an easier and more straightforward way to accomplish the same net result.
SWIG makes it fairly easy to compile C/C++ libraries into Tcl loadable modules. But in general, use of the module is limited to the single Tcl version whose header files were used in the compilation. Stubs-enabled extensions by contrast can be loaded by any version of Tcl which supports the Stubs interface. The aim of this project would be to give SWIG the ability to generate the code necessary to compile a library directly into a Stubs-enabled module.
stevel Note that Critcl already does this, so perhaps an alternative would be to add an option to Critcl to take a SWIG description, or perhaps a simplified C API description, and generate the Tcl bindings from it.
Report on Tcl projects in the Google Summer of Code