Ideas for Smalltalk GSoC 2013 projects

Ideas collected, now look at the Projects page to see how those ideas evolved into real projects.

Event based library integration in Pharo image and VM

Level: advanced

Possible mentor: Davorin Rusevljan

Possible second mentor: ?

Description

Event based libraries help handling large number of concurrent connections and sources of async events. Many successful projects use such libraries like for instance Node.js and Twisted. To be used in Pharo suitable interface in image and quite possibly in VM would be needed.

Technical Details

Two main candidate libraries for inclusion would be libev and libuv. It would be necessary to find suitable and efficient non delaying way to transfer callbacks from library to process inside Smalltalk image. One path suggested by Elliot Miranda was to investigate Multi threaded VM and see if some of its functionality can be used as is or as a base for further development.

Benefits to the Student

Getting in depth understanding of event driven frameworks and interfacing to Smalltalk virtual machine.

Benefits to the Community

Having efficient event driven library available in Smalltalk would open possibility of writing efficient servers in Smalltalk that can handle large number of concurrent connections.

FAST Java Model

Level: intermediate

Possible mentor: Nikolas Anquetil
Possible second mentor: Yuriy Tymchuk

Description

For in depth source code analysis a support of abstract syntax trees is required. FAST is an abstract syntax tree extension for FAMIX meta-model that is used by Moose technology. The goal of this project is to create a Java version of FAST.

Technical Details

As programming languages are different, their AST representations are different too. FAST model aims for creation of as generic as possible core that can be extended for different languages. Also the structure of a model allows creation of generic algorithms like symbol resolution, metrics calculation and rule checking that will work for any language. A prototype of FAST for Smalltalk is already implemented by Yuriy Tymchuk as well as couple of nodes for Java. During the project a student will implement the rest of the Java model, and improve some parts of PetitJava parser that is used by FAST.

Benefits to the Student

The student will gain a deep understanding of a Java syntax and abstract syntax tree model. He will also learn about PetitParser framework, and gain knowledge about software modeling and analysis.

Benefits to the Community

Community will get a FAST model for Java that can be used for software assessment with Moose. Also this model can be used later in PhD projects such as automation of source code translation form C++ to Java.

Pharo Image running on top of VirtualBox

Level: intermediate

Possible mentor: Clement Bera

Possible second mentor: Marcus Denker, Camillo Bruni

Description

Archiving Pharo / Squeak Image is not easy : it depends on a VM, that depends on a processor and an OS. Sometimes, we find old Pharo / Squeak Image that we cannot run because we have lost the appropriate VM. This
is even more relevant when the project rely on a specifically built VM. Moreover, sometimes we have also lost the Pharo / Squeak Image sources from that image and we cannot read easily the code. I propose then to save the working image with its sources, changes file and VM into a virtual box image in order to have it working on top of virtual box easily forever. This way the archived image will only depends on the computer processor, and not on VM, OS, computer processor, source file, change file.

Technical Details

The student would have to identify a minimum linux kernel in order to run Pharo. Then, he would have to implement some Pharo code so that by entering 'Smalltalk saveAsVirtualBoxImage' in workspace it would create
a virtual box image in the same folder, with the current VM, source file, change file, image and the minimum linux kernel. This command will probably go get some part of the virtual box image (for instance the linux micro kernel) or some external tool as Vagrant (http://www.vagrantup.com) somewhere on the internet. Running the virtual box image would directly run the Pharo image on the Pharo VM through a start-up process. Lastly, the student would have to set up a Jenkins job on the Pharo-contribution continuous integration server that create a Pharo virtual box image. If some time is remaining, the student would have to find a solution to manage the Pharo image crashes in virtual box.

Benefits to the Student

The student will learn some smalltalk (networking, commandLineHandler), how to set up a build in a Jenkins continuous integration server and some linux command line. He will also have a nice impressive open source
tool to show.

Benefits to the Community

The community will benefit from the archiving tool. The Pharo virtual box image could also be interesting for some experiments.

Unicode CLDR integration into Squeak/Pharo 

Level: beginner?

Possible mentor:

Possible second mentor: Paul DeBruicker

Description

The Common Locale Data Repository CLDR (http://cldr.unicode.org/) is a maintained set of locale specific information for use in programs.  Creating a package that integrates it into Squeak & Pharo would help with i18n and l10n for the platforms.  It would be preferable to be able to load a limited number of locales rather than the whole thing into every image.  We would probably benefit from having a Fuel based data repo somewhere that can access the updated and interpreted standards.

Technical details

The CLDR is constantly edited and updated and published as a spec and set of XML files.  Those files would need to be regularly downloaded and parsed to create a publicly available repository that Smalltalkers could access to import only those locales they're interested in having in their images. A repository on github that contains a Fuel file per locale would be an acceptable solution.

Benefits to the Student

Work with international standards, web services, wider knowledge of the affects of the actions of politicians and history.

Benefits to the Community

Being able to properly interpret, compare, and format currencies, dates, times, inside their images.

SmalltalkOpenCL

Level: Advanced

Possible mentor:

Possible second mentor:

Description

Build the interface from Pharo to OpenCL (https://www.khronos.org/opencl/) This will automatically provide a great opening for Pharo to work with the underlying OpenCL libraries for effective use of multi CPU cores and across GPU's. Infact a Apache Hadoop like capability to do a map reduce can also be leveraged that will make it immensely beneficial for the enterprise stakeholders. Sometimes the very capability does exist is more important than the actual utilization in deciding the use of technology in enterprise units. (This along with a proper interface to MQ / MQ like messaging interface will be a great platform for enterprise computing)

Technical Details

In this project the student will:

• define and implement an interface to the OpenCL C library
• work on porting some existing samples to Pharo Smalltalk

Benefits to the Student

The student gains a huge understanding of the current trends in parallel programming of modern processors across various hardwares.

The student should have good understanding and grasp of C / C++ as well ability to work FFI in Pharo Smalltalk.

Benefits to the Community

An interface to an industry standard platform for parallel programming

Implement Fast Byzantine Paxos in Slang

Level: advanced

Possible mentor: Paul DeBruicker

Possible second mentor:

Description

Paxos is a system for ensuring consensus across a network of processors (e.g. multiple images on multiple computers or cpus on the same hardware). Fast Byzantine Paxos is Paxos extended to ensure reliability
in the face of arbitrary failures among processors, lying from processors, collusion among more than once lying processor, etc. Fast Byzantine Paxos is just a version of Byzantine Paxos that omits a step seemingly trading network latency for additional CPU work. But I'm not sure of the tradeoffs.

My basic understanding is that among a set of images (technically "processors" but I'm going to use image because it seems more relevant here) you construct a quorum. That quorum calculates and agrees on a
response to a client request. The quorum survives and is the unit of computation but the individual images inside it change in make up and number through time as images and machines die and come back. The quorum maintains and replicates the state among its member images. The images in the quorum can at any time assume at least one of 5 roles (client, acceptor, proposer, learner, leader) for that quorum and most play all but leader all the time. The images can participate in more than one quorum. There is only one 'leader' per quorum (but the
leader can be any image in the quorum and is 'elected' by the quorum members) and sends messages to others in the quorum to process. I'm not sure of the gory details but the client sends a request to the quorum, the quorum processes it, and sends back the one agreed upon response regardless of how many machines are in the quorum that fail or fail to respond during the computation. Paxos describes all the intra process communication that needs to take place to ensure that the quorum provides reliable responses to requests in the face of hardware and network failures. Implementing it in Slang would potentially make it faster than in image (guessing) because C and it could be a plugin. 

Technical details

It is my understanding that implementing Paxos from scratch and covering all corner cases and failure modes is very very hard. Probably also confusing. Sorry I don't know more but here's a zip of the papers I've collected that describe ways and issues around implementing it: http://dl.dropbox.com/u/4460862/paxos-papers.zip.

Benefits to the Student

Learn Smalltalk, Slang. Implement something hard. Also build a robust distributed Smalltalk system.

Benefits to the Community

With enough images you can just persist everything in the image and each image can be a reasonable size. Other benefits include making a (hardware, network) failure resistant server Smalltalk process.

Split Mocketry into separate Mock Objects and Specification DSL frameworks

Level: Intermediate

Possible mentor: Dennis Schetinin

Possible second mentor: Denis Kudryashov

Description

The Mocketry framework offers two really nice features: Mock Objects themselfs and an extendable DSL for Specifications within Smalltalk syntax. Both features are essential for a language like Smalltalk, but they correspond to distinct (although, tightly connected) domains. Thus, they should be separated into different frameworks, independently useable.

Technical Details

The Mocketry code is not very sophisticated, so it shouldn't be too complex to understand it and find a point for the segregation.

Benefits to the Student

A student will:

• get better understanding of TDD ideas
• understand interior engines of Smalltalk
• see how simple it is to implement such sophisticated (for other languages) things like mocks and a custom DSL

Benefits to the Community

Two distinct loosely-coupled frameworks are better then a monolithic architecture. This, at least, widens the usage area for both frameworks. 

A New Trait Implementation

Level: intermediate

Possible mentor: Damien Cassou

Possible second mentor: Stéphane Ducasse

Description

Inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. Existing schemes based on single inheritance (e.g., in Java), multiple inheritance (e.g., in C++), or mixin (e.g., in Ruby), all pose numerous problems for reuse.

To overcome these problems, we designed a new composition mechanism called Traits [1], now included in programming languages such as PHP, Perl and Pharo/Smalltalk. Traits are pure units of behavior that can be composed to form classes or other traits. The trait composition mechanism is an alternative to multiple or mixin inheritance in which the composer has full control over the trait composition. The result enables more reuse than single inheritance without introducing the drawbacks of multiple or mixin inheritance.

Technical Details

Pharo (http://www.pharo-project.org) is a new open-source Smalltalk-inspired programming language and environment [2]. It provides a platform for innovative development both in industry and research. Traits are
integrated in Pharo but barely used due to a lack of support in the development environment. The current implementation of traits in Pharo merges the trait methods into the classes that use the trait. This merging of external methods into classes makes the implementation of the development tools harder.

To solve this problem, the student will have to:

• evaluate alternative implementations of traits that do not merge methods into classes;
• implement the best alternative in Pharo (this alternative will have to be (un-)pluggable);
• adapt the Pharo development tools (e.g., code browser, refactoringtools, and versioning tools).

The project will be realized in the Pharo environment (http://www.pharo-project.org).

Benefits to the Student

• Understanding of how programming languages and IDEs are implemented;
• Integration into a prolific research group, fond of software development and programming languages;
• Potential integration as a master and/or PhD student either within the group or within one of its numerous partners around the world (Switzerland, Chile, Belgium, Argentina, Italy).

Benefits to the Community

• Simplify writing new code with traits and help understand trait-based existing code;
• Enable rewriting of non trait-based code with traits to improve its design and reuse;
• Provide a basis to continue research around traits with a better implementation.

[1] S. Ducasse, O. Nierstrasz, N. Schärli, R. Wuyts, and A. P. Black.
Traits: A Mechanism for fine-grained Reuse. In TOPLAS: ACM  Transactions
on Programming Languages and Systems 28(2) p. 331—388,  March 2006.
http://scg.unibe.ch/archive/papers/Duca06bTOPLASTraits.pdf

[2] A. Black, S. Ducasse, O. Nierstrasz, D. Pollet, D. Cassou, and M.
Denker. Pharo by Example, Square Bracket Associates, 2009.
http://pharobyexample.org/

[3] D. Cassou, S. Ducasse, and R. Wuyts. Traits at Work: the design of
a new trait-based stream library. In Journal of Computer Languages,
Systems and Structures 35(1) p. 2—20, 2009.
http://scg.unibe.ch/archive/papers/Cass08a-NileNewKernel-ComputerLanguages.pdf

Nautilus In Spec

Level: intermediate

Possible mentor: Stéphane Ducasse
Possible second mentor: Benjamin Van Ryseghem

Description

Nautilus is the new default browser for Pharo3.0. But because the UI is fully platform dependent, it can not be used in other dialects (contrary to OB by example).
The goal is to migrate the entire Nautilus UI to a Spec based version, ti be able to export Nautilus.

Technical Details

Currently Nautilus is fully written using Morphic (and even have its own morphic widgets). The idea is to redefine the existing UI using Spec, rethink the way interaction between sub widget is done,
and provide a way to statically describe Nautilus UI.

Benefits to the Student

The student will acquire knowledge about Morphic. He will also learn how Spec is working and its mechanisms for event propagation as well as widget static description. He will also learn how to define new Spec widgets and how to link them to already existing Morphic widgets.

Benefits to the Community

The community will benefit of a more modular UI for Nautilus (since every one can then specify its one Nautilus UI), as well as a browser which may be used in different dialects
 

Programming tools for Pharo based on Type Inference

Level: intermediate/advanced

Possible mentor: Camille Teruel
Possible second mentor: Stéphane Ducasse

Description

Type inference mechanisms can be used to compute the types of variables from the source code. This information is very interesting in the context of a dynamically-typed language like Smalltalk. Several
type inference tools already exists for Smalltalk but the type information they bring has not revealed all its potential yet. The student will have to leverage this type information with new programming
tools.

Example of such tools are:

• Code analysis tools:
• better "implementors of" and "senders of" lists
• dead code finder
• Development tools:
• type mismatch hints at compile time
• better code completion

Technical details

The student will have to analyze existing type inference tools and choose an appropriate solution. Then he will have to learn how to build UIs with Spec.

Benefits for the Community

• New useful development tools
• 
  * Improvement of existing code base thank to these tools

Benefits for the student

• Use a highly reflective dynamic language
• Learn the basics of type inference
• Learn how to make UIs with Spec
• Have an impact on the code base of a large project

Better rewriting rule tool

Level: Intermediate

Possible mentor: Stephane Ducasse

Possible second mentor: Andre Hora

Description

The refactoring browser is based on a powerful rewrite engine which transforms AST. However it is quite cumbersome to write rewrite rules. There is a need to build a tool to help programmers defining their own transformation.

Technical Details

Benefits to the Student

•     learning AST
•     learning AST transofrmation
•     learning AST pattern matching
•     User interface definition

Benefits to the Community

A tool that is cruelly missing.

Smalltalk IDE in Emacs

Level: intermediate

Possible mentor: Damien Cassou
Possible second mentor: Nicolas Petton

Description

Smalltalk IDEs (integrated development environments) are quite powerful as they feature code browsers, debuggers, object inspectors, immediate feedback... Nevertheless, such IDEs have been lacking great text
manipulation features that have been available for decades in good text editors such as Emacs and Vi. Moreover, many developers outside the Smalltalk community have developed great skills in their favorite editors and they are often reluctant to switch to different tools. In this project we propose to port some of the best Smalltalk tools to the Emacs platform so that developers can use very high-level tools while still using their day to day editor.

Technical Details

The student will benefit from the already existing Shampoo project (http://dmitrymatveev.co.uk/shampoo/) which already features a Smalltalk code browser in Emacs. In this project, the student will have to:

• fix the problems that make it hard to start using Shampoo;
• continue the development of the Smalltalk code browser in Emacs and write unit tests;
• using a test-driven approach, implement a debugger interface in Emacs using the already existing Smalltalk debugger infrastructure;
• using a test-driven approach, implement object inspectors and immediate feedback (do-it and print-it).

The project will be realized in the Pharo environment
(http://www.pharo-project.org) as Shampoo already supports Pharo and
Pharo has a new debugger infrastructure decoupled from its user interface.

Benefits to the Student

• Knowledge of Smalltalk, Emacs Lisp and inter-process communication;
• Integration into a prolific community, fond of software development and programming languages;
• Potential integration as a master and/or PhD student within research groups of the community around the world (France, Switzerland, Chile, Belgium, Argentina).

Benefits to the Community

With such a tool, more developers will be able to join our community as many don't want to stop using their favorite editors. Additionally, even existing Smalltalk developers will benefit from the Emacs platform that has improved steadily for decades.

 

Search Indexing of Smalltalk image

Level: Intermediate

Possible mentor: Aik-Siong Koh

Possible second mentor: Ian Chai

Description

All Smalltalk development environments can now search for implementors, senders or strings using brute force. The results are usually just listed alphabetically. This project will use search technology to index and page rank all the packages, classes, methods and comments in the image. Search results will be returned quickly and ranked intelligently. It will be a Search Engine for Smalltalk in Smalltalk. A search browser will be created to accept search strings and return columns of hits for packages, classes, methods and comments listed according to their page ranks. Time permitting, an autocompletion capability will be implemented to suggest relevant methods for code writing. The code will be made portable to all Smalltalk dialects.

Technical Details

The Anatomy of a Search Engine http://infolab.stanford.edu/~backrub/google.html

Demo on Search Indexing of Smalltalk image videos:

http://youtu.be/2YVU_-EAZ4c

http://youtu.be/twVX7yOg5C0

http://youtu.be/C9a7F-Uwop8

Benefits to the Student

The student will learn the important areas of search technology and object oriented programming. The student will experience creating something that is immediately useful to all Smalltalk programmers.

Benefits to the Community

Fast and intelligent search of Smalltalk code will help the community advance Smalltalk development even faster. Additional programming capabilities can be built on top of the search capabillities.

Gadget (the inspector)

Level: Intermediate

Possible mentor: Juan Pablo Sandoval Alcocer

Possible second mentor: Alexandre Bergel

Description

Understanding how an application behaves at runtime requires adequate tools. However, MessageTally, the standard Smalltalk code profiler, is very limited in the kind of analyzis it can carry out. Spy (a profiler framework) is an attempt that has been made in the past, however Spy suffers from poor design, typically forcing profilers to contain a heavy dose of duplicate code.

In this project, we plan to produce Gadget, a portable, open and flexible profiling platform. Hapao [1], Kai [2] and Rizel [3] will be migrated from Spy to Gadget.

Gadget will not only provide features to measure code coverage, time consumption, snapshot comparison, but will provide tools to monitor memory consumption.

All these features will provide to Pharo developers the tools to create domain specific profilers and reuse the features of different implemented profilers in Gadget.

Technical Details

In this project the student will:

• define and implement a profiler metamodel.
• learn and implement instrumentation and/or sampling techniques.
• migrate three profilers from Spy to Gadget.

Benefits to the Student

The student will (i) address performance problems; maintainability, design and evolution issues. (ii) get a better understanding of the executing environment of Pharo; (iii) learn reflection and dynamic analysis basics.

Benefits to the Community

• Have a new open-source profiler framework with a smooth implementation
  of the feedback and experience from the community.
• Allow the community to develop new profilers on top of Gadgetwhich are
  easier to implement and maintain.

Thread Profiler

Level: intermediate

Possible mentor: Alexandre Bergel
Possible second mentor: Juan Pablo Sandoval

Description

Any operating system comes with a tool to monitor the CPU consumption of the running application (e.g., Activity Monitor on mac, .... in windows). These tool give for each process the amount of CPU and memory it consumes. Unfortunately, Smalltalk does not have such a tool. Pharo and VisualWorks offers the process browser, which is a rather primitive. No indication about the resource consumption is given. A first prototype has been proposed (Loom http://objectprofile.com/#/pages/products/loom/overview.html), however it currently works on VisualWorks and offers a rather sluggish user interface.

This project is about offering a reliable tool to monitor the resource consumption of the running threads. Our tool will be made portable and will run on Pharo and VisualWorks.
The tool will offer nice visual chart to monitor the consumption, as most OS process monitors do.

Technical Details

The program will present:

• A window with a table of thread's information
• A visual time line that represents the tread evolution
• Several Buttons to handle the threads

Benefits to the Student

The student will (i) get a better understanding of the executing enviroment of Pharo and VisualWorks (ii) make a contribution that will be use by several users (iii) practice in building GUI applications/frameworks, improve Smalltalk programming skills.

Benefits to the Community

The Smalltalk community would use the new browser like a tool in order to review and handle the consumption of the processes in a visual way. We expect Thread Profiler to help improve Pharo and VisualWorks applications.

Debugger Improvements

Level: intermediate

Possible mentor: Andrei Vasile Chis

Possible second mentor: Nicolas Passerini

Description

The Smalltalk IDE contains an advanced debugger that allows the programmer to explore and change the program as it is executing.

Over the last years, the Smalltalk community has realized a number of experiments and libraries that, taken together, form a powerful core of a new, even more advance debugger subsystem:

• a new Debugger Model
• a first graphical user interface for this model
• an AST (Abstract Syntax Tree) interpreter
• research in the direction of Object Centric Debugging

The goal of this internship is to take the exiting code and build a new debugger infrastructure.

Technical Details

To solve this problem, the student will have to:

• implement a user interface using the Spec framework
• extend the AST Interpreter to support debugging (e.g., single step execution)
• extend the debugger model to use the AST interpreter
• integrate with Object Centric Debugging

Benefits to the Student

• learn about Abstract Syntax Trees, Debuggers and IDEs.
• learn about advanced concepts of language implementation.
• learn about design and implementation of debuggers for dynamic languages
• understand how programming languages and IDEs are implemented;
• integration into a prolific community, fond of software development and programming languages;
• potential integration as a master and/or PhD student within research groups of the community around the world (France, Switzerland, Chile, Belgium, Argentina).

Benefits to the Community

For the Smalltalk community, the current debugger is an indispensable tool for daily development. An improved debugger will have a direct impact on the productivity of every developer and will, last but not least, support the development of Smalltalk IDEs themselves.

Improving the inspection of expressions in the debugger

Level: beginner/intermediate

Possible mentor: Andrei Chis

Possible second mentor: Nicolas Passerini, Tudor Girba

Description

The debugger is a central tool in any programming language, as it helps developers understand the dynamic behaviour of applications. Furthermore, in Smalltalk, it can also be used to write code and thus extend applications while they are running.

One important aspect that is missing in the current Pharo debugger, is the ability to view the value of intermediate expressions involved in method calls. For example consider the call:

^ self doSomething: (anArray at: 2) with: aStream next onlyIf: aCondition isValid.

In order to view the values of the expressions (anArray at: 2), (aStream next) and (aCondition isValid) we have to directly go into the actual method call. Furthermore, viewing the return value can be more difficult, if we do not store it into a variable.

The goal of this project is to add support for exploring these kind of expressions by using dedicated widgets. For example, one alternative might be adding pseudo variables into inspectors, while another might consist in using popups that display these values for any expression selected in the editor.

Technical Details

The student will have to understand how the debugger works, and will  have to familiarise himself with the new debugging infrastructure. Also, he'll have to look into at least a framework for building UIs (Spec/Glamour).

Benefits to the Student

He will get a deep understanding of how debugging is done, on how the debugger works and he'll also interact with a framework for building UIs.

Benefits to the Community

The community will bet a better debugger, in which values passed and returned by methods could be easily explored using different widgets.

Smalltalk Native-Code Debugger

Level: Intermediate.
Possible mentor: Guido Chari.
Possible second mentor: Javier Pimás.

Description

Smalltalk is a powerful environment for software developing. It allows the development of high-level abstractions, and it is highly dynamic and reflective, which promotes analyzing and changing objects at run-time. Debuggers are essential tools, particularly in Smalltalk because they allow developers to understand a program as well as to find and fix defects as they are running.

Debugging native applications, on the other hand, is very hard. Many native applications can't be developed using high level abstractions. Furthermore, as they consist of native-code, debugging them requires understanding and modification of very low-level operations on raw memory at run-time [1], and also a close interaction with the operating system [2][3].

Using Smalltalk to control and debug low-level code would be a great aid in the native-code development process. It would allow not only to control programs status and trace, but also to easily develop a myriad of high-level tools that analyze and modify native-code as it runs.

Technical Details

There are many different kinds of debuggers, and many mechanisms are already mature for implementing features in them [4]. Warp[5] is a recently born project to implement on Pharo a wrapper for the PTrace system call, the essential operating system debugging API. With the addition of already existing powerful  high-level tools for low-level programming, as NativeBoost[6] and Waterfall[7], this project will allow to have a native debugger interface for any process from a Smalltalk image, and create a complete ecosystem for Native-Code developing from Smalltalk.

The first steps will include understanding the ptrace system call, and about x86 instructions coding and decoding. This can be done by completing the wrapper of ptrace, which consists of only one function with many different functionalities and improving the disassembler for x86 binary code. After this the student will be able to develop tools for aiding in native-code debugging, like a specialized inspectors and debuggers for watching the value of variables, adding breakpoints, watchpoints, modifying memory and code.

Benefits to the Student

• gain experience in high-level and low-level programming.
• learn about how debuggers work under the hood
• gain experience on the usage and development of a complete Smalltalk native-code development toolchain.
• learn about native-code assembling and disassembling.

Benefits to the Community

Lately, there has been more and more evidence that high-level written software for low-level development is starting to succeed. Smalltalk provides an ideal platform for exploring this domain because of its powerful reflective capabilities. NativeBoost already promotes lot of new possibilities for working dynamically on the Pharo environment with complex low-level tasks. More tools for having a complete and outstanding tool-chain are needed and the native debugging interface is one of the most prominent and promising.

A native-code debugger will help Smalltalk VM and low-level programmers, because it will leverage all their Smalltalk programming skills into low-level programming. It could even bring closer non-VM programmers to VM code, as it would remove a barrier of entrance to VM programming.

Having a fully working native-code debugger would be a killer app that can attract lots of low-level developers to Smalltalk, specially Virtual Machine and C/C++ programmers.

Distributed Issue Tracker

Level: (intermediate, advanced)

Possible mentor: Stephan Eggermont
Possible second mentor: Diego Lont

Description

A native smalltalk distributed issue tracker. It should have basic issue tracking functionality
including attaching files/pictures/code. It should have a native interface, a web interface
and a scripting API. Primary development is in Pharo.

Issue trackers have different kind of users. To make clear that different users have different
needs, persona can be helpful.

Isabelle is an information technology student looking for an interesting language and environment
to learn. She wants to contribute to and learn from a smart community and needs interesting
experiences on her cv. She has already learned the basics of a few mainstream languages
and feels ready to try something more exotic. Smalltalk seems interesting as the origin of
many inventions.

Yann is the major developer of a web-based platform based on Pharo and Seaside. He needs
to ensure the platform keeps working smoothly and is updated regularly with the latest
changes. In production he uses the released versions. He fears the major clean-ups Pharo is
making make it difficult for him to keep up. He is dependent on a few old unmaintained
squeaksource packages.

Janine just found an interesting old package on squeaksource. It was last changed in 2007.
She has been using smalltalk for a few years, so knows what to expect when trying to load
an unmaintained package. There are some missing classes that still exist in squeak.

Tony is the developer of a package that is used with nearly all smalltalks. He mainly works
with a commercial smalltalk and keeps just enough contact with the Pharo community to keep
his package working. He has complained about some changes that made it necessary for him to
change his package structure. He mainly updates the Pharo version on his way to and from the
office in the train.

Eve maintains a few of the crucial Pharo kernel packages. They are under heavy development
and once in a while everything breaks, leading to a flood of issues. They mostly come from
outsiders, as she talks daily with the Pharo core team. She has to close a lot of them as
duplicates. She also has to review code that gets attached in one form or another to the
issue.

Daniel is a maintainer of the vm that forms the basis for the Pharo vm. The vm is used by
many more projects.

Lara is a release manager for a well known linux distribution. Pharo is just one of 30 languages
that are included in the distribution. Before doing a release she scans the issue tracker for
any show stoppers. She had to stop including environments because of security issues.

Technical Details

The recent decision by Google to deprecate and stop its API for the Google Issue Tracker
used by a.o. the Pharo, Seaside, MOOSE and Metacello projects makes it necessary for those
projects to select a different issue tracker. The timespan before this decision has to be made is
too short for the development of a new issue tracker from scratch.

Now most development in Smalltalk uses distributed version control systems, either Monticello or Git,
the question arises why these projects still would want to use a centralized issue tracker. The
long-standing problems in keeping squeaksource up-and-running are only one example of the problems
of depending on centralized infrastructure. Other examples are the move of Lukas' repository and the
number of times where the Pharo CI infrastructure was not available, especially on holidays and weekends.  

The currently used issue trackers cannot work disconnected. Integrating the issue tracker in
the CI workflow of the projects is crucial.

The goals of the persona should be translated into a storymap. Delivery should be iterative
and incremental, driven by value to the community and technical risk. The student is expected
to be active on the mailing list and discuss development there. This includes handling
(source) contributions by others.

There is a small prototype available.

Benefits to the Student

• getting to know the difficulties of issue tracking/the workflow of open source projects
• experience with distributed systems
• experience an agile open source environment

Benefits to the Community

• better integrated workflow
• native issue tracker, accessible both in-image, web and automated
• showcase for productive environment  

Questions

Here are seven persona. Which ones are missing/should be fleshed out?

SmalltalkHub Continuous Integration Service

Level: intermediate

Possible mentor: Nicolas Petton
Possible second mentor: Esteban Lorenzano

Description

Continuous integration services are becoming a fundamental part of programming process, and tools for easy the execution of builds are emerging and being integrated directly into the version control systems (like travis and github). We propose to add this facilities to pharo flag version control service (SmalltalkHub), to facilitate the adoption of continuous integration processes into our community.

Technical Details

This project implies the extension of SmalltalkHub and the configuration of building jobs into the pharo community public infrastructure (and explore the possibility of using travis itself).

Benefits to the Student

• Use a highly reflective dynamic language
• Learn to develop a complex multi-module architecture with several communication pipes.
• Learn about REST interfaces.
• Learn about integration of different services developed in different
  technologies.
• Learn web application development techniques.

Benefits to the Community

• have a platform for automate continuous integration processes
• indirectly increase the quality level of the frameworks developed

Git integration

Level: intermediate

Possible mentor: Damien Cassou

Possible second mentor: Camillo Bruni

Description

Git (http://git-scm.com) is a famous distributed revision control system that is gaining momentum.

Smalltalk systems have had distributed revision control systems for quite some time now. However, the Smalltalk community can't keep up with all the wonderful works done in other communities. We should reuse as much of what exist today to stop loosing time reinventing the wheel. That's why this project is so important.

Technical Details

The goal of this project is to integrate Git within Smalltalk. The Git object model has already been implemented
(http://smalltalkhub.com/#!/~FileSystemGitDev/FileSystem-Git). The student will have to implement what is missing, that is to say:

• the Git network protocol with good unit-tests (already started);
• a new back-end for Monticello (a revision control system used in some Smalltalk environments) that fetches from and saves to a Git repository;
• a simple graphical user interface (written in the Spec GUI framework) to manipulate Git repositories.

The project will be realized in the Pharo environment as Pharo is the development platform we used to start the project. To fulfill the project's goal, the student will first have to learn Pharo, Git (and its underlying network protocol) and Spec.

Benefits to the Student

• integration into a prolific research group, fond of software development and programming languages;
• discover completely different ways to program object-oriented applications;
• understand how protocols are designed and implemented;
• get insights about designing graphical user interfaces;
• potential integration as a master and/or PhD student either within the group or within one of its numerous partners around the world (Switzerland, Chile, Belgium, Argentina).

Benefits to the Community

This work will allow the community to reuse existing tools (e.g., hosting services, continuous integration, web interfaces, code review) instead of loosing energy and time reinventing the wheel.

Dialect-Portable Monticello

Level: intermediate

Possible mentor: Sean DeNigris

Possible second mentor: ?

Description

Extend FileTree and Cypress to handle dialect feature differences like namespaces vs. prefixes

Technical Details

The pieces are all available and a proof of concept has been done, but what's required is a deeper look to integrate the idea consistent with the existing design.

Benefits to the Student

The student will get a deep understanding that ultimately, no matter how many layers are on top, most data boils down to text, which can be freed from wherever it lives, to go wherever it's needed. Also, the student will have the opportunity to contribute to a key core open source tool, with all the community involvement that implies.

Benefits to the Community

There are many great libraries for Squeak/Pharo vs. VW that would be extremely useful on the other side (like Xstreams - which has an older version on Squeak/Pharo, and PDF Artefact). There is very little preventing near-automatic porting between the ecosystems, and this project would address that.

UIPainter

Level: advanced
Possible mentor: Stéphane Ducasse
Possible second mentor: Esteban Lorenzano

Description

The purpose is to offer a way to easily describe and create UI using a point and click interface. This interface should be extendable, as well as the widget proposed. The Painter should also propose a simple way
to link widgets together, and to locally redefine behaviours.

Technical Details

Using Spec, the UIPainter should be able to generate the needed methods (and Layouts).
The UI corresponding class could also be generated.

Benefits to the Student

A deep understanding of UI creation. A good set of knowledges about widgets interactions. The students will also benefits of an understanding of Spec at all the levels.

Benefits to the Community

The community will benefit of a new tool for generating UIs easily using the new platform independent UI framework. A UIPainter will help developers by improving the widgets reuse and simply the process of UI creation

Spec platform/framework Independence

Level: intermediate
Possible mentor: Stéphane Ducasse
Possible second mentor: Nicolas Petton

Description

The goal is to improve and ensure the platform independence of Spec. Indeed, one of Spec goals is to generate widgets on multiple UI rendering framework (Morphic, Seaside, etc). The student could improve Spec by providing a set of widgets for multiple framework, and ensure the usability of Spec in different Smalltalk dialect.

Technical Details

Currently running only in Pharo, Spec should be able to be used easily on Squeak. One interesting target is to be able to use it in Amber by example.

Benefits to the Student

The student will acquire knowledge and experience about different Smalltalk implementation. He will also experience different UI framework, and trough Spec how widgets interact with each others.

Benefits to the Community

The community will benefit of the coolness of Spec, and will also have a single way to define UIs regardless of the framework used to render them.

Animation Library based on Athens

(Student proposal by Mariano Vicente)

Level: intermediate
Possible mentor: Guillermo Polito
Possible second mentor: (?)   

Description

Animation Library based on Athens

Technical Details

Animation Library, to make visual animation objects in the screen, such as move, bounce , etc.

Benefits to the Student

• Learn the basics of animations and moving objects.
• Learn about manage of graphics
• Understand the concepts of movement functions

Benefits to the Community

• Get a library to make custom animations with the posibility of add new ones.

Framework to render and to edit LaTeX formula

Level: Advanced

Possible mentor: Hilaire Fernandes

Possible second mentor:

Description

The framework should come in two parts:

1. rendering of LaTeX math formula.
2. LaTeX equation editor

Technical Details

The tools should depend on:

• Pharo freetype interface to render font.
• the Morph user interface tool kit.

No external libraries or on-line services should be used.

Why LaTeX and not MathML: LaTeX formula can be hand edited, MathML not really as there are not very human readable.

Benefits to the Student

Learn how to represent, to render and to edit mathematic expressions.
Learn how to design an editor tool: model, view and controller.

Benefits to the Community

A library to render and to edit mathematic formula.

Worksheet toolkit

Level: Intermediate

Possible mentor: Hilaire Fernandes

Possible second mentor:

Description

A Smalltalk based spreadsheet toolkit with a basic editor to:

• add/delete cells
• edit cells formula
• render aspect

May depends on PetitParser to parse cells formula.

Technical Details

The toolkit should be customizable.

Benefits to the Student

Learn how to modelize a spreadseet, to design a view and editor.
Learn how to design an editor tool: model, view and controller.

Benefits to the Community

A spreadsheet toolkit.

Morphic widgets for browsing

Level: intermediate

Possible mentor: Tudor Girba
Possible second mentor:

Description

Browsers are key software development tools. The Pharo/Moose environment already offers sophisticated support for constructing browsers (for example, through Glamour). However, the effectiveness of these browsers highly depends on the rendering capabilities, and currently, the Morphic widgets offer limited capabilities.

The goal of this project is to construct multiple widgets that make browsing smoother and more scalable. These widgets will at the very least influence the rendering available in Glamour. Ideally, the widgets should be integrated in Spec, and perhaps Pharo.

Why Morphic? Because Pharo/Moose is a highly dynamic environment that deserves appropriate widgets. And because the effort is less science fiction that one might tend to think.

Technical Details

Scalable list widget:

• The list will offer parallelized loading (without blocking the ui)
• The list will offer dynamic paging (like google photos or twitter)
• The target is to handle easily 100k items

Multi-category search widget:

• This will behave similarly with the Mac Spotlight widget
• The widget will react on every keystroke

Smart tabs

• The tab behaves similarly with the one from Eclipse: it has a label and an associated menu
• The tabs are lazily loaded
• The tab label resizes smartly depending on the size of the overall widget
• A first implementation exists in Glamour, but it needs consolidation and extension

Popup inspect widget

• The widget will appear on demand and will contain a morph (typically, a simple text morph)
• The widget will disappear as soon as the input is lost
• This widget will useful for replacing the "print it" behavior that currently directly affects the existing text
• To some extent, the widget will behave like the inspector from Eclipse

Watcher widget

• The widget will behave like the preview functionality from the Mac Finder
• On a certain key combination, the preview window appears and it displays a morph
• Loading the contents of the preview must not block the ui
• A first implementation exists in Glamour

(Optional) Grid widget:

• The grid widget allows navigation similar to an Excel spreadsheet
• Each cell in the grid knows its row and column
• The grid allows the manipulation both by column and by row
• The grid can be navigated with keys
• The grid accepts any morph as a widget
• The size of the columns and rows can be customized individually (and ideally take the size of the contained widgets)

Benefits to the Student

• The student is expected to want to deal with user interface design
• You will familiarize yourself with the domain of browsing
• You will gain experience in user interface design
• You will learn Glamour (read about it here: http://www.themoosebook.org/book/internals/glamour)

Benefits to the Community

The community will benefit from significantly better browsers

Tree models visualization

Level: intermediate

Possible mentor: Usman Bhatti

Possible second mentor: Yuriy Tymchuk

Description

Moose platform (http://www.moosetechnology.org) does very good job for data analysis. Recent FAST extension allows one to model an AST for a source code. The idea behind this project is to develop an interactive tree visualization that will gradually improve analysis of the underlying model.

Technical Details

Roassal graphical visualization engine will be used to visualize tree models. One of a use cases are abstract syntax trees. In particular FAST implementation for Smalltalk. Tree visualization should improve model understanding and incorporate interaction. Upon creation of the visualization, development of a supporting framework is welcome. This way when FAST will be extended to model another languages visualization for them could be introduced in an easy way. Main issues when working with large tree visualization:

• for source trees different nodes have different meanings,
• size of the model often makes visualization difficult to analyze.
• adding interactivity in the visualization to annotate interesting entities, analyze them individually/independently.

Benefits to the Student

• learn Roassal visualization engine
• learn about software modeling
• learn about model representation

Benefits to the Community

Result can be used in Moose for AST visualizations as well as all other models that conform to tree hierarchy, this will greatly improve their analysis.

Improving Roassal Scalability

Level: Intermediate

Possible mentor: Vanessa Peña-Araya

Possible second mentor:Alexandre Bergel

Description

The Roassal visualization engine is getting more users in the Smalltalk community every day. This means more complex visualizations are created using Roassal, and the amount of data the user wants to represent is larger. However Roassal is still behind to answer this demands as it lacks from scalability for big visualizations, resulting in very slow displaying and events answering.

In this project we plan to fix this problem and allow Roassal to become a efficient tool.

Technical Details

In this project the student will define and implement a strategy for faster displaying for the visualizations and events reaction. This includes understanding the techniques currently used in other visualization tools.

Benefits to the Student

• Learn and understand Roassal, including its structure and design,
• Learn graphical tools techniques mainly for rendering and event responding.

Benefits to the Community

Allowing the community to have a faster and efficient visualization tool, making Roassal a powerful visualization engine and answering to the demand to render large amount of data.

Roassal in Amber

Level: Intermediate (?)

Possible Mentor: Nicolas Petton or Manfred Kröhnert

Possible Second Mentor: Nicolas Petton or Manfred Kröhnert

Description

Roassal has proven to be a useful and top tool for the entire Smalltalk community. It has been used both in academic and commercial organizations. Proof of this is that it has already been ported to other Smalltalk dialects such as VisualWorks.

Nowadays, where the Web reigns as king of information sharing, Amber is one of the most robust responses from the Smalltalk world. Thus, porting Roassal in Amber will promote Roassal as a good alternative for interactive visualization development on the web.

Technical Details

The project consists in:

• Getting Roassal to compile automatically
• Adapt Roassal to Amber’s environment constraints
• Connect Roassal with an optimized HTML5 canvas rendering library (RaphaelJS [1], D3 [2])

[1] http://raphaeljs.com/
[2] http://d3js.org

Benefits to the Student

The student will (i) better understand both Roassal and Amber internals, (ii) improve his / her javascript skills (iii) make an important contribution for the community

Benefits to the Community

Both Roassal and Amber projects will have several benefits. Roassal will attract web users, leading to an increase in interest and use of both Amber and Roassal.

We expect it will help Roassal users to easily share and show their visualizations on the web, making it available to a wide range of viewers (not only Pharo users).

Graph-ET

Level: Beginner

Possible Mentor: Alexandre Bergel
Possible second mentor: Tudor Girba

Description

The necessity of having a chart-drawing tool integrated with Roassal is increasing day by day. Graph-ET is a tool that allows the user to create and draw charts with small and expressive Smalltalk instructions. The user may enter a large variety of entries, and the program with parse it to fit the users need. For example, the user may use a domain of words and visualize the length of those words with just two lines of code. The nice thing about Graph-ET is that it’s very simple to see results also the interface allows the user the play with their charts in a
variety of ways. The idea is having a kind of EyeSee but with Roassal as rendering and adding more power of desition to the user.

Technical Details

Graph-ET is a software that needs to draw to work, for that it mainly uses Object Profile’s Roassal to make the drawing and the interaction work.

Benefit to the Student

The student will learn a lot more of Smalltalk and Pharo environment. Also he will learn some chart visualization and learn to solve all the problems that come with it. Not to mention learning entry parsing. Mainly he will face with serious and critical decisions that will change the fate of his program, but that will mean significant learning process for him.

Benefit to the Community

The community will have the pleasure of making fast charts with small and expressive instructions; this will lead to a more simple way of making and drawing charts. The users of Roassal will enjoy a tool that fit their needs and that work well with the software they already own.

Tools for developing Amber web clients from Pharo.

Jabber client / server

Gamification of Pharo development process

Athen's HTML5 canvas

Amber CouchApp framework

DBXTalk on NativeBoost

 Level: intermediate
 Possible mentor: Guillermo Polito
 Possible second mentor: Esteban Lorenzano

Description

DBXTalk database driver nowadays uses a native library called OpenDBX. This library stands as an adaptor between different database drivers, implemented in C. This native library supposes many problems:

• it should be normally compiled for each different platform (Windows, *nix, macosx) and database vendor
• each of its bugs should be fixed in a C source code base
• OpenDBX do not expose the particular behavior of each database vendor, but their common denominator
  difficulty for distribution, and problems to locate libraries.

This project proposes to use NativeBoost bindings to remove the necessity of the native openDBX library, simplifying the deployment of applications using relational databases, and moving all the code base to Smalltalk.

Technical Details

This project supposes the replacement of openDBX old FFI bindings by direct nativeBoost bindings to the database drivers. The new drivers should be completely written in Smalltalk, and take care of platform and library resolution in the image side. These drivers should be polymorphic while also enabling the access to specific API provided by database vendors.

Benefits to the Student

• Use a highly reflective dynamic language
• Learn the basics of foreign function interface (and its exponent NativeBoost)
• Learn how to manage external resources and platform specific native code
• Put into usage its object design skills to transform a structured designed library into an object oriented one

Benefits to the Community

• A more malleable and full smalltalk implementation of relational database drivers
• Easier deploy for applications using relational databases
• Database divers exposing their particular apis, providing access to features not available before 

SciSmalltalk - Solving Ordinary Differential Equations in Smalltalk

Level: (intermediate)

Possible mentor: Serge Stinckwich

Possible second mentor: ?

Description

SciSmalltalk is a new Smalltalk project, similar to existing scientific libraries like NumPy, SciPy for Python or SciRuby for Ruby. SciSmalltalk already provide basic functionalities under MIT licence: complex and quaternions extensions, random number generator, fuzzy algorithms, LAPACK linear algebra package, Didier Besset's
numerical methods, ... We want to extend SciSmalltalk to solve ODE (Ordinary Differential Equations). SciSmalltalk is available here: https://github.com/SergeStinckwich/SciSmalltalk

Technical Details

The development of this project is to be done in Pharo Smalltalk, but the code could be portable to other Smalltalk flavors. We want to build a library of ODE solvers that take care about performance without sacryifing flexibility. OdeInt could be used as an example to develop a Smalltalk library: http://headmyshoulder.github.com/odeint-v2/index.html. The student will need to have basic knowledge about differential equations and numerical algorithms. Units tests should also be provided.

Benefits to the Student

The student will help the Smalltalk community in a very concrete way. The student will learn to design well-designed code with tests.

Benefits to the Community

Having a basic ODE library is very important if we want to develop Smalltalk in new domains like robotics, high performance computing, computer vision, bio-computing, .... The lack of numeric librairies hamper the use of the Smalltalk in a scientific context at the moment.

Smalltalk Modbus Industrial Communications Protocol

Level: Intermediate

Possible mentor: Ben Coman - I can provide the domain knowledge and general programming assistance

Possible second mentor: Someone to help advise on good Smalltalk architectural patterns

Description

Smalltalk has high potential as a SCADA (Supervisor Control And Data Acquisition) platform for industrial plant automation. A SCADA system provides a real-time animated interface for plant operators to monitor and control industrial processes, by providing graphical mimics of meters, gauges, valves, motors, tanks and field start/stop buttons [1]. A pre-requisite of this is communicating with a PLC (Programmable Logic Controller) to which the electrical wiring of the plant sensor and control devices are connected. The de facto communications protocol for SCADA/PLC communication is Modbus. This project will implement the Modbus protocol in Smalltalk.

Technical Details

First published in 1979, Modbus is an application level master-slave/client-server communications protocol used for SCADA/PLC communications. Much of its popularity as a de facto standard is due to its relatively simple implementation compared to other industrial communications protocols. The student will use the Modbus specifications [2] to implement ModbusASCII, ModbusRTU serial line protocols and ModbusTCP. This will be done first using a simulator [3], then later using a physical I/O module [4] to control some real world devices.  A stretch goal is to integrate with the server side of last year's GSoC project "MMI (Man-Machine Interface) with Amber" [5].

[1] Sample animation at http://en.wikipedia.org/wiki/SCADA (circles are motors, triangles are valves, half circles are valve controllers.)
[2] http://www.modbus.org/specs.php (about 50 pages - not all required)
[3] http://www.plcsimulator.org/Home (or similar)
[4] http://www.audon.co.uk/modbusio/mbiodaio.html (or similar)

[5] http://gsoc2012.esug.org/projects/mmi-amber

Benefits to the Student

• gain experience in client/server programming
• gain experience in a widely used industrial communication protocol.
• practice breaking down and implementing a real-world specification - good training for the workplace.
• controlling the real world from Smalltalk will be cool
• a local industrial plant might be approached to help with a practical test case, maybe leading to ongoing employment.

Benefits to the Community

This project expands the industry segments into which the Smalltalk community can consult. It provides a foundation for development of a SCADA system in Smalltalk.

The industrial automation industry is a great source of bespoke application development. It is a service industry where the source code is owned by the client, since every industrial plant is different requiring a custom written SCADA application. Many plants run 24x7, so ongoing modifications need to be made online without shutting down the operator's console, for which Smalltalk is ideal (not all current commercial SCADA platforms can do this).

Phratch, a port of Scratch to Pharo 2.0

Level: intermediate

Possible mentor: Jannik Laval

Possible second mentor: Serge Stinckwich

Description

Phratch (https://code.google.com/p/phratch/) is an ongoing port of Scratch and BYOB on Pharo 2.0. The current prototype is still suffering from a lot of bugs. Part of the work will be to add unit tests to the existing project. Even if this is a port to Pharo, we will try to build a new version that is flavor-independent. The long term objective of Phratch is to be able to use it for teaching software engineering and robotics.

Technical Details

Pharo and some knowledge of Squeak

Benefits to the Student

Student will participate to a very cool project.

Benefits to the Community

Scratch will be rebuild on top of a modern Smalltalk version and will benefit from lastest development in the
core library and VM.

Arduino Web Interface

Level: Beginner

Possible mentor: Ricardo Moran

Possible second mentor: Gabriela Arevalo

Description

The Arduino project for Pharo currently includes a set of core classes that allow you to communicate with an Arduino board. This is generally enough for some projects. However, no user interface has been implemented yet. This project involves the development of a web interface that would allow to control an arduino from a web browser.

Technical Details

The project could be implemented using Seaside and Amber, and it would involve developing a set of generic web controls for accessing the state of the arduino pins. These web controls must allow the user to easily compose a website to control his arduino project. The arduino pins could be classified as:

1. digital input
2. digital output
3. analog input
4. analog output (pwm)

Each of these pin types would have a different graphical representation, and maybe inputs could be plotted over time. Other devices (like motors, lcd displays, and such) could be modelled as well.

Benefits to the Student

The student will learn how to control an Arduino from Pharo and to develop a web application (possibly using Seaside and Amber).

Benefits to the Community

The community would benefit from having a set of generic web controls to interact with an Arduino, which would in turn encourage the development of interesting projects using Pharo and Arduino. The interaction via web is specially interesting for home automation projects because it allows you to control some aspects of your home from anywhere in the world, provided that you have access to a web browser.

ROSTalk, control robot on the web

Level: advanced

Possible Mentor : Serge Stinckwich

Possible second Mentor : Anyone ?

Description

ROS (Robot Operating System) is a software to standardize communication between robotic applications. Communication between components is performed using messages channels named "topic". A gateway named ROSBridge allow ROS components to controlled from a web browser that supports HTML5 WebSockets protocol. The gateway converts ROS topics in JSON objects used in a web application. JavaScript is the default language of many modern web browsers (Firefox, Google Chrome, ...) but this is a limited language as soon as you want to
build reusable components. ROSTalk is a prototype developed by Serge Stinckwich based on Amber Smalltalk, which allows to use the language Smalltalk from a web browser in order to control robotic software.

Technical Details

Smalltalk Amber, JavaScript, ROS middleware

Benefit to the Student

• Learn how to use ROS middleware and develop complex Smalltalk application on the web.

Benefit to the community

• will enhance visibility of Amber Smalltalk to larger audience.