Google Summer of Code 2009 Project Ideas
Last updated at 6:33 pm UTC on 18 March 2009
See also Project Ideas for Google Summer of Code 2007
See also Project Ideas for Google Summer of Code 2008
Mentor: Aik-Siong Koh
Level: Intermediate
Currently, Squeak can call external programs using FFI or DotNet Bridge. But it is not yet possible for external programs to call Squeak and make it behave as plugins in the external programs. Such a capability will open many more doors to deploying Squeak. This project aims to extend DotNet Bridge to allow any .NET program to call and control Squeak. Specifically, Squeak will be made into a plugin that a CAD program will call and control to get added capabilities. The student will gain experience in C#.NET and Smalltalk which are important languages in static and dynamic typing respectively. A working CAD plugin will also have commercial potential.
Mentor: Klaus D. Witzel
Level: Beginner
Princeton University WordNet is a large lexical database of English, with nouns, verbs, adjectives and adverbs grouped into sets of cognitive synonyms. The WordNet DB is very often the starting point for sense mapping, natural language processing, NL parsers and query systems, mining the Web, natural language understanding and other cognitive and commonsense computation tasks.
In this project the student will implement a Smalltalk GUI for browsing the WordNet DB and also provide an interface for other Smalltalk tools which want to benefit from accessing senses and glosses of the lexical database.
Mentor: Stephane Ducasse and Marcus Denker
Level: Intermediate
The goal is to enhance the new compiler.
- One of the task is to provide a better error handling:
- Report error of token that is not in the Scope (ie Class not define, variable not in the scope,..)
- Provide a way to capture errors. For example when Monticiello load code it should be able to mute errors and make a report at the end of the load.
- Another task is to work on the Parser.
- Parsing is slow. May be a hand written Parser would be better and be easier to report errors.
- The Parser should also be able to work with a syntax highlight (eg Shout)
- Work on a Bootstrap compiler:
- When you are working on the compiler often you break it then since you have no rescue compiler you will be jammed. The solution is to automate a copy of the compiler and make it possible to switch between them and also adopt fixes...
- Make a better model of Scope and Varaible:
- Now the scope and variable models are very complex. The idea would be to design a better model. It would be profitable for the ir-decompiler and the ast-to-ir-generator.
Mentor: Lukas Renggli
Level: Intermediate
Smalltalk lacks an extensible editor component, that can not only be used to program in Smalltalk but also be extended to facilitate domain specific languages (DSLs). The goal of this project is to implement the model and view of a powerful editor component that is highly configurable and customizable. Possible features include, but are not limited to: configurable keyboard bindings, unlimited undo/redo, copy and past with multiple clipboards, multiple editing areas, bookmarks in text, folding of text, multiple selections, rectangular selections, syntax highlighting, completion mechanism, template mechanism, collaborative editing, etc.
Follow up of Safara last year project.
Mentor: Brenda Larcom
Level: Intermediate
Ross Method is a declarative language for expressing business rules, developed by Ronald G. Ross. Although the language is entirely diagrammatic, and widely used by database practitioners, no diagram editor is available; existing proprietary editors use text equivalents instead of diagrams. In this project, the student will use the CASE Framework to model business rules using Ross Method, and Connectors to display and edit the rules. The resulting editor will become part of the Trike security analysis tool. Students interested in an additional challenge are welcome to write the security analysis portions as well, add gesture recognition using Genie, and/or implement simulating the rules rather than just modeling them. Students will gain experience in Smalltalk, business rules modeling, cutting edge requirements security analysis, working with a research team, and Agile development.
Mentor: Brenda Larcom
Level: Beginner
Data flow diagrams show the components of a system and the relationships between these components; they are commonly used to express system architecture. No DFD editor is currently available in Squeak. In this project, the student will use Connectors and Genie to develop a cross-platform, pen-based editor for existing DFD model classes. The resulting editor will become part of the Trike security analysis tool. Students will gain experience in Smalltalk, Connectors, Genie, architectural modeling using data flow diagrams, cutting edge architecture security analysis (if desired), working with a research team, and Agile development.
Mentor: Janko Mivšek
Level: Intermediate
The goal is to build a web portal for a Smalltalk code to be browsable, searchable and also one-click loadable into the image. Loadable with the help of in-image agent, which is connected to the portal and receive an appropriate command to load the Monticello (or some other) package into image. The point is in simplicity of this process, to ease the barrier of entry for newcomers to Squeak and Smalltalk in general.
Mentor:Alexandre Bergel, Stephane Ducasse, Michael Rueger
Level: Beginner, Intermediate
The ultimate goal is to significantly increase the speed of loading and saving Monticello project. Every single user of Monticello will find benefit in it, including people using Squeak in industries.
More information available here.
Mentor:Esteban Lorenzano
Level: Beginner, Intermediate
Continues SqueakDBX. Link: http://wiki.squeak.org/squeak/6052. Now that I have finished the core of squeakDBX (there are still some features to be included soon), I am planning to start the GLORP (http://www.glorp.org/) integration. Actually, this may include two parts:
1) The integration of GLORP with squeak is completely hardcoded with PostgreSQL driver. Because of this, first I will do a refactor in GLORP in order to enable it to support different drivers. I will create a PostgreSQL driver with the things that GLORP already has. We invited Alan Night to have dinner with us when he came to Argentina. We told him our ideas and discuss for a while till we get a first design of this refactor.
2) Create a SqueakDBX driver for GLORP just like the one we are planning to do for PostgreSQL.
Through this project, the squeak and pharo community will hopefully be able to interact with major database engines, such as oracle and mssql, besides those which are open source, like postgresql and mysql. Moreover, by integrating this plugin with GLORP, will allow us to generate a complete and open source solution to relational data base access.
Finally, I want to say that many times (perhaps always), I rather use an OODB like GemStone or Magma that RDBMS, but unfortunately, many many times (we did a survey at collage and seems to be 90%) the client of our software require us to use certain persistence strategy like RDBMS. Because they now about it, because they already have license, because they want to execute SQL statements, or any other reason. So, for all those cases, we rather user smalltalk and RDBMS than having to use other programming language.
Mentor:Rajeev Lochan
Level:Intermediate
Web based software is becoming the preferred way of offering software. It centralizes maintenance yet offers very easy user access. More details at http://en.wikipedia.org/wiki/Software_as_a_Service
You will build a web server that allows users to create freeCAD (http://www.ar-cad.com) drawings inside any Internet browser. Project will implement Seaside and would be developing a browser plugin such as one that is available for etoys http://www.squeakland.org/ .
Mentor:Rajeev Lochan
Level:Intermediate
The project is to help making Virtual Presentations over the internet.
1)A Seaside and/or Comet web application needs to be developed, where a presenter(host) can upload his/her Presentation File (.ppt/.odp).
2) The server has to process that into an intelligent format (flash like).
3) The host can then invite guests to his presentation session. The host has control over the slide the guests are able to view. The host has 2 buttons (Back and Next) to navigate between the slides. When the host clicks either of the buttons, the action is sent to all his guests' browsers and the corresponding slide is shown to them.
4) The host and guests can talk to each other using an implementation of Jabber in Seaside.
This could be useful in a scenario when the presenter has to explain his/her slides to a set of guest users, without having to show his/her desktop(which usually happens in Desktop Sharing) and thus reducing the bandwidth costs and also it is less susceptible for hacking of shared desktop.
Mentor:Phua Khai Fong
Level:Intermediate
3D Web is coming with Croquet/Cobalt http://opencroquet.org freeCAD/Cobalt is a 3D Modeler in Croquet/Cobalt. It needs collision detection to behave like a game or physics engine. Student will use Smalltalk and Slang to build or port Collision Detection similar to that in Open Dynamics Engine. http://www.ode.org/
Mentor: Craig Latta
Level: Intermediate
The Spoon project aims to improve Smalltalk pedagogy, collaboration, and deployment through better system organization. One task is to identify the essential elements of the Smalltalk object memory, to aid in the creation of a minimal memory which can load and unload live code modules. One very useful tool in that identification has been the simultaneous and interactive visualization of all the object reference relationships in a memory. So far we've used Munzner's H3 layout algorithm as implemented by the Walrus 3D graph visualization tool, in combination with extensions to Squeak's interpreter simulator. Integration of the visualization component with the simulator would make interactive visual exploration of memories easier and faster, and likely lead to new insights regarding memory structure. It would also make such visualization useful for teaching Smalltalk, beyond the relatively narrow needs of Spoon's minimization task. We suspect Cobalt would be an excellent environment for the visualization.
Students will adapt techniques from H3, Walrus, or other sources as appropriate, and gain experience in Smalltalk, interactive 3D development, and virtual machine simulation.
Mentor:Eliot Miranda
Level: Advanced
The Cog VM is a new faster VM for Squeak/Croquet. It is a hybrid just-in-time compiler and interpreter VM written in Smalltalk using the existing VM's Slang Smalltalk-to-C compiler and a processor simulator to allow full development in Smalltalk and production via translation-to-C. Currently Cog is running on x86 using the closure bytecode extensions currently being adopted by the latest Squeak VMs. There are a number of projects that can be worked on, in order of priority:
- port to ARM and the iPhone. This involves
- developing an ARM simulator plugin using an open-source ARM simulator such as SkyEye
- writing a back-end to generate ARM code and rewrite insructions for inline cache management and updating of object references in machine-code,
- generating glue to connect the generated machine-code to the interpreter that conforms to the host platform's ARM C ABI
- writing platform support code to make memory executable and flush the instruction cache.
- port to PowerPC on a suitable OS (e.g. PS3, Mac OS X). This involves
- developing an ARM simulator plugin using an open-source PowerPC simulator such as SkyEye (?)
- writing a back-end to generate PowerPC code and rewrite insructions for inline cache management and updating o object references in machine-code,
- generating glue to connect the generated machine-code to the interpreter that conforms to the host platform's PowerPC C ABI
- writing platform support code to make memory executable and flush the instruction cache.
- replace the existing garbage collector with a proper scavenging ephemeral collector and a proper segmented memory model that can add new segments via memory-mapping (mmap/VirtualAlloc) and release these back to the OS, i.e. can grow and shrink.
Mentor:Eliot Miranda
Co-Mentor:Aik-Siong Koh
Level: Advanced
A major limitation of the current Squeak is that it cannot be used as a DLL that can be loaded by other programs and provide functionality in the form of a library. One architecture that allows convenient use in this form is a threaded FFI that supports "send-backs", means to discover objects and message selectors exported by the Smalltalk DLL and use these from the client program to send messages into the Smalltalk DLL and retrieve results, packaged using suitable procedural abstractions to provide a usable interface. The cliennt program then loads the Smalltalk DLL and invokes some initialization routine that loads an image and returns once the image has initialized and reached its idle loop, at which point it is ready to accept requests. This involves
- extending the existing FFI or the Alien FFI with support for threads such that the VM can perform call-outs on multiple threads and receive call-backs from multiple potentially unknown threads without blocking the main Smalltalk VM thread in the style of the VisualWorks THAPI FFI extension (authored by Eliot Miranda).
- building an object export scheme that allows handing out opaque handles to objects to the client program, protecting it from the moving of objects by the garbage collector
- packaging the VM and an image as a DLL, e.g. including the image as a resource, or as a file
- writing start-up Smalltalk code that exports the APIs the developer wants to export from their Smalltalk image, and that signals the VM DLL's initialization routine when start-up is complete
