links to this page:    
View this PageEdit this PageUploads to this PageHistory of this PageTop of the SwikiRecent ChangesSearch the SwikiHelp Guide
Project Ideas for Google Summer of Code 2007
Last updated at 12:39 am UTC on 28 March 2007
Click on each title to go to a more detailed description of the projects. Please note that the scope of the project is negotiable: if you think the project you'd like to undertake can't be completed in two months, we can agree to reduce its scope.

Collaborative development

Mentor: Ralph Johnson
Level: Advanced
Create a collaborative programming environment, based on Squeak and Croquet.
The aim would be to leverage the collaboration feature of Croquet in order to create a Squeak environment in which a lot of people can share the browsers, inspectors, etc., and they could also talk to each other using microphones. Everything could be recorded and played back.
This would be great for teaching, because teachers could work with a couple of people on a demo and record it, and then play it back as a way of teaching.

Fast binary format

Mentor: Stephane Ducasse
Develop a package format to be able to load fast code without recompiling source code and supporting atomic loading of code as in professional Smalltalk environments.

New IDEs

Mentor: Stephane Ducasse
Improve the current set of tools and IDE supporting user defined refactorings and code transformation.
Squeak 3.9 integrates Traits but the tools are lacking full trait support. This project will start with the current implementation of the Refactoring Engine and extend it to support Traits.
In a second step, new ways of presenting code and navigation should be proposed.

Reimplement IDE Tools in a Structured Way

Mentor: Andrew P. Black
The Squeak IDE consists of a collection of tools that have evolved to have inconsistent capabilities. For example, one can edit in the debugger, but not refactor from there. There's a new, powerful tool framework called the Omnibrowser, but many of the tools still need to be ported to this framework, and given the same feature set.

Improving the Compiler Frameworks

Mentor: Marcus Denker
Squeak's compiler framwork is hard to understand and not easy to extend. Over the last years, a number of projects used the compiler framwork from the Closure Compiler (the NewCompiler) for experiments. Even with some progress (e.g. the compiler backend has been extended to support old-style non-closure code and extended to support 3.9 pragmas), many things are needed until the NewCompiler can replace the old squeak compiler.
The goal of this project is to improve the closure compiler with regard to the code it generates for closures. The Student should design and implement a number of schemes to optimize the perfomance of closures.
This project follows the previous one (which was part of ESUG SummerTalk 2006) around the new generation compiler.


Mentor: Bryce Kampjes
Exupery is a compiler written in Smalltalk that compiles bytecodes to machine code. It is currently under heavy development, and there are many areas where it can be improved, including:
and many others.


Mentor: James Foster
Produce a namespace implementation for Squeak.
This will involve:

VM Tests

Mentor: Brian Rice (provisional)
Level: Intermediate
We are comfortable that the VM behaves the same on all platforms, what is missing is verification that the platform dependent apis behave the same.
What needs to be done is
  1. identify all the external api in the standard VM across all the platforms (windows, mac, unix, risc). And document their behavior.
  2. write Sunits to test all the api interfaces.
  3. ensure each api does proper sanity checks to prevent a crash, or exploit.

Error Handling for VM Primitives

Mentor: Brian Rice (provisional)
Level: Intermediate
The VM does some degree of sanity checks when primitives are invoked. However, it returns only success or failure. There are many places where a primitive can fail for several different reasons. In those places, the Smalltalk code has to re-discover what the problem is. Altering the logic so that a diagnostic message is recorded detailing why the primitive failed would greatly help.

This would require changes in Slang, changes in the Smalltalk code to pull the data, and changes in platform specific APIs.

Unicode support

Mentor: Todd Blanchard
Squeak's support for Unicode can be improved:

Seaside and Sails

Mentor: Giovanni Corriga
The idea of this project is to enhance Seaside framework with automated tools, scripts and conventions in order to help people to develop simple web applications in Seaside in a much faster way.

OWTRTA - One Wiki to Rule Them All

Mentor: Keith Hodges
Develop a wiki translation engine using Pier, enabling Pier to routinely read and write other wiki formats. Using a configuration of Pier with the OODBMS Magma as a back end, test and explore scalability issues with the goal of importing wikipedia. The ability to have a full text search of the persisted data is required.

Seaside Load Balancing/Deployment Management System

Mentor: Todd Blanchard
Getting a Seaside app into production is still a very labor intensive process. Load balancing is ad-hoc, and there is no ability to track the status of a number of Seaside instances.
There's need for a system Load Balancing/Deployment Management System to allow central management of a Seaside app in production.
This project might be broken down into a couple different parts. Apart from working in Squeak, there will probably be shell/ruby scripting and apache configuration scripting to do.

An HTML Viewer based on HTMLParser/DOM

Mentor: Todd Blanchard
This is strictly a GUI kind of task - we have a parser that can build a dom from HTML in the wild and also handles css. Write a morphic widget that can render this dom as a widget. Support form components and hyperlinks.

Sake - A Squeak based make-like tool

Mentor: Brian Rice
Level: Beginner
Squeak can run scripts through OSProcess, but it doesn't have a framework for declarative building of various targets. Rake demonstrates an interesting approach to this problem that could be implemented in Squeak readily and used for building and testing automation beyond the Squeak image. It could even offer new facilities for the image itself using the Installer tool.

Peek - Debugging and Viewing Framework

Mentor: Giovanni Corriga
Peek is a different kind of object inspector that incorporates features from an inspector and debugger to give the illusion of being able to take apart any object into its components (instance variables and such) and watch it tick. It will have a graph-based interface, where objects are represented by nodes and pointers by edges.

Better localization support for Squeak

Mentor: Serge Stinckwich
Level: medium
Since the 3.8 version, the Squeak UI has been translated in several languages: english, german, french, spanish, japanese, ... The current translation framework still suffer from several drawbacks that we like to solve in this project with a more modular approach.

Sophie extensions API refactorings

Mentor: to be assigned.
Sophie is an open-source multimedia documentation creation tool build on top of Squeak. Sophie comes with a framework to allow people to add extensions to the Sophie Application, but might require some refactoring to make it into an interface that a Squeak Programmer could easily use to add extensions/widgets to Sophie. Example widgets/extensions should be provided at the end of the project, say a frame to execute Smalltalk code, an EToy reader frame, or a Twitter api.

Sophie book format re-engineering

Mentor: sriggins .
Sophie writes stores books in an undocumented XML format. This needs to be cleaned up, and possibly moved towards one of the W3G standards for XML markup definitions. At the end of the project we would need a Sophie Book that fully describes how the XML is constructed, and what is needed to build books using just the XML formatting. A Smalltalk api which currently exists needs to be consolidated and refactored so that users of Seaside applications can have the ability to generate Sophie Books from information collected by their Seaside application by loading just a subset of Sophie.

Support for Live External Editing

Mentor: Brian Rice
Level: intermediate
Squeak often is criticized for not making itself editable through commonly-used text editors, at least as a live system (and editing file-outs is awkward). Common Lisp has solved this problem through its SLIME Emacs mode and associated Swank protocol for introspection by external IDE's (also used for Eclipse-based editing). This project involves constructing a similar protocol for Squeak, as well as a system for a common cross-platform editor like Vim or Emacs to edit methods or comments or class definitions in buffers and then pass their contents back to Squeak in the same context. Operation should be able to be driven either entirely from Squeak or entirely from the editor.


Mentor: Eddie Cottongim
Level: Intermediate to Advanced
As Squeak's GUI has become more sophisticated, its performance has degraded. NuBlt is a high-performance refactored version of the classic Squeak BitBlt that essentially removes as many of the per-pixel branches and functional calls as possible. A proof-of-concept version already exists, and shows promising performance gains of up to 8x, but does not implement all of the Bitblt capabilities. The scope of work could include adding more combination rules (currently, about 17 of 34 are implemented), stable enough operation to run a Squeak image, further performance improvements, and implementing WarpBlt (an arbitrary quadrilateral deformation addition to BitBlt). This work requires knowledge of Squeak's VM plugins.

Replace FileDirectory with Rio: 

Mentor: Keith Hodges
Level: Beginner to Intermediate
The FileDirectory class is currently the main handle for files in squeak. Rio has been developed specifically as cleaner, more versatile and easier to use replacement for FileDirectory. This project is to begin the process of porting the Kernel of Squeak as used by KernelImages to use RioKernel, so as to make both Rio and FileDirectory optional loadable packages. Further work would include porting some other essential packages to use Rio and RioKernel (i.e. Monticello, SqueakMap etc)

Port Squeak to Plan 9

Mentor: Chao-Kuo Lin (provisional)
A Plan9 port of Squeak would provide obvious technical benefits to both communities. Certain aspects of Squeak devpelopment stand benefit from the presence of such a uniquely powerful host OS–the immediate availability of the entire Plan 9 toolkit (including such programs as the acme text editor) is certainly nothing to scoff at. Plan 9 simultaneously has much to gain from ready access to Squeak; thanks to Plan 9's clean design, it would be quite easy to give the OS access to such things as Squeak's Morphic UI toolkit and Seaside web toolkit.

Add commenting capabilities to SqueakMap

Some SqueakMap packages are broken and it would be nice to add comments to them to tell future travelers and the maintainer that someone should tend to it