Pharo GSOC 2019
Ideas List

Pharo is a pure object-oriented programming language and a powerful environment, focused on simplicity and immediate feedback (think IDE and OS rolled into one).

Table of Contents

Guidelines

Information for Students

These ideas were contributed by our developers and users. They are sometimes vague or incomplete. If you wish to submit a proposal based on these ideas, you may wish to contact the developers and find out more about the particular suggestion you''re looking at.

Being accepted as a Google Summer of Code student is quite competitive. Accepted students typically have thoroughly researched the technologies of their proposed project and have been in frequent contact with potential mentors. Simply copying and pasting an idea here will not work. On the other hand, creating a completely new idea without first consulting potential mentors is unlikely to work out.

If there is no specific contact given you can ask questions on the general Pharo development list pharo-dev@lists.pharo.org. See the Pharo community page for information on available mailing lists and how to subscribe.

Adding a Proposal

Please propose your own project by following the following template. You can edit the list on github here: https://github.com/pharo-project/pharo-project-proposals/blob/master/Topics.st and send a pull request.

     PharoTopic new
       title: ''The name of your project'';
       contact: ''email address'';
       supervisors: ''Supervisors names'';
       keywords: ''keywords separated by spaces'';
       context: ''a description of the context of the project'';
       goal: ''description of the goal'';
       level: ''Beginner or Intermediate or Advanced'';
       yourself.
    

Administration

Do not hesitate to ask questions. Administrators of this year’s application are Jigyasa Grover, Oleksandr Zaytsev, Serge Stinckwich.

Pharo GSOC Topics

TitleIPFS for Pharo
Emailmarcus.denker@inria.fr, pavel.krivanek@gmail.com
Supervisors Marcus Denker, Pavel Krivanek
Keywordspeer to peer file systems
Context IPFS is a peer-to-peer distributed file system that seeks to connect all computing devices with the same system of files. In some ways, IPFS is similar to the Web, but IPFS could be seen as a single BitTorrent swarm, exchanging objects within one Git repository. In other words, IPFS provides a high throughput content-addressed block storage model, with content-addressed hyperlinks. This forms a generalized Merkle DAG, a data structure upon which one can build versioned file systems, blockchains, and even a Permanent Web. IPFS combines a distributed hashtable, an incentivized block exchange, and a self-certifying namespace. IPFS has no single point of failure, and nodes do not need to trust each other. IPFS right now is implemented as a server process in Go and allows the global file system to be mounted as a user space filesystem. In addition, the server provides an API. A real integration of IPFS with Pharo would require a complete implementation of IPFS in Pharo (projects are already in early stages to implement it in JavaScript and Python). But the client API allows us already now to do experiments and assess the usefulness of IPFS in the context of Pharo. More information: https://ipfs.io
GoalThe goal of this Project is to implement a IPFS client library using the API to communicate with the existing server and start to experiment how IPFS can be used with Pharo. For example, extend the launcher to load images via IPFS, distribute the files of smalltalkhub or provide access to resources via IPFS.
LevelNormal
CandidateTopic still free

TitleEnhancing Pillar
Emailstephane.ducasse@inria.fr, guillermopolito@gmail.com
Supervisors Stéphane Ducasse, Guillermo Polito
KeywordsPillar OpenDocument LibreOffice OpenOffice document tree visitor
ContextPillar is a markup syntax that is easy to use and learn. This markup syntax generates a document tree. P illar can export to HTML, LaTeX (to produce PDFs) and Markdown. Pillar has already been used in several projects (http://www.smalltalkhub.com/#!/~Pier/Pillar) and most of the pharo books and mooc
GoalThe goal of the project is to do help in the development of the new iteration of Pillar. Previous development effort introduced a better architecture but there are still some points to improve. - Documenting certain classes - Improving the archetype design - Separating command-line into object configurators and command-line - Producing a new version of ectastic http://guillep.github.io/ecstatic/ that uses the lastest version of pillar. - One subgoal of this project is to add the standard OpenDocument export format (used by LibreOffice and OpenDocument).
LevelBeginner
Candidate

TitleAuthoring and exploring scientific models in Pharo
Emailkonrad.hinsen@cnrs.fr, serge.stinckwich@gmail.com
Supervisors Konrad Hinsen, Serge Stinckwich
Keywordsscientific models
ContextScientific research increasingly relies on computational models, but these models are usually not reified in a way that permits sharing and processing them with computational tools. Natural language summaries are incomplete and imprecise, whereas implementations in software are complex and not portable. The digital scientific notation Leibniz (https://github.com/khinsen/leibniz) aims at reifying computational models as specifications rather than implementations.
GoalWorking with scientific models requires interactive tools, both for authoring new models and exploring existing ones. The Pharo live object environment is an excellent basis for developing a suitable interactive workbench. Many individual steps can contribute to such a development: implementing well-known examples from various scientific domains (e.g. Newton's equations for celestial mechanics or the Lotka-Volterra equations for population dynamics), extensions to Pharo development tools (inspector, debugger, browser, ...) for handling models formulated in Leibniz, etc.
LevelIntermediate
CandidateTopic still free

TitleCharting library
Emailcyril@ferlicot.me, julien.delplanque@inria.fr, olk.zaytsev@gmail.com, alexandre.bergel@me.com
Supervisors Cyril Ferlicot-Delbecque, Julien Delplanque, Oleksandr Zaytsev, Alexandre Bergel
KeywordsData Visualization, Data Science, Plotting, Grammar of Graphics
ContextIn recent years community has been showing great interest in doing scientific computing or data analysis, as well as building machine learning applications in Pharo. Data is central in all those fields. Visualizing data in charts is very important for understanding it and presenting the results. Even though Roassal can be used for plotting data, it has a very generic API and makes even the most simple charts very complicated. Other tools like MatplotLibBridge or ChartJS are just connectors to external libraries which create static images and do not allow us to use some of the most valuable features of Pharo environment, such as live inspection and debugging.
GoalBuild an easy-to-use framework for visualizing data with charts, similar to matplotlib in Python or ggplot2 in R. This tool should have the flexible API based on the Grammar of Graphics. It can be built on top of Pharo's Geometry library and should be able to use different backends such as Morphic or Bloc interchangeably.
LevelIntermediate or Advanced
CandidateTopic still free

TitleProjectional Editor for Advanced Pharo Debuggers
Emailsteven.costiou@inria.fr, vincent.aranega@inria.fr
Supervisors Steven Costiou, Vincent Aranega
KeywordsDebugging Editor IDE AST
ContextCurrently in Pharo, the Abstract Syntax Tree (AST) is generated from the source code, and stored into a cache. Each modification of the source code invalidates the cache and triggers the generation of a new AST object. Every annotation of the AST is lost in the process.
GoalProjectional editors make possible to edit different representation of the same underlying model. This project aims at building a projectional editor which manipulates an AST model instead of source code. With this tool, it will be possible to maintain a permanent representation of the system as an AST, and to new tools directly based on it, as new debugging tools.
LevelIntermediate
CandidateTopic still free

TitleExtension of Iceberg to support Fossil
Emaildmason@ryerson.ca, guillermopolito@gmail.com
Supervisors Dave Mason, Guillermo Polito
Keywordsiceberg fossil
ContextIceberg is a significant improvement for cooperative development on Pharo. It is intended to support multiple Version Control Systems, but currently only works with Git. Fossil is another VCS that is a more integrated, full feature alternative, particularly well suited to smaller team development.
GoalThe goal of this project is to add an additional VCS to Iceberg. In addition to making the particular VCS available, dependencies on Git will be exposed and Iceberg will become more generic so that other VCSs, such as Mercurial or SVN, can be more easily added.
Level Intermediate or Advanced
CandidateTopic still free

TitleImproving code completion
Emailstephane.ducasse@inria.fr, olk.zaytsev@gmail.com, esteban.lorenzano@inria.fr, juampiboy@gmail.com
Supervisors Stéphane Ducasse, Oleksanrd Zaitsev, Esteban Lorenzano, Juan Pablo Sandoval Alcocer
Keywordscompletion
ContextAutomatic completion is really important. The current code completion already defines some good behavior but it can do better.
GoalThe goal of the project is to improve the ecompletion infrastructure: The tasks are: (1) study the existing approaches (NOC and NEC), (2) Write some tests to characterize specific behavior, (3) Improve the noise introduced by the Symbol table usage, (4) build more heuristics.
LevelIntermediate
CandidateTopic still free

TitleSpec Cassowary Layout
Emailtesonep@gmail.com guillermopolito@gmail.com
Supervisors Pablo Tesone, Guillermo Polito
Keywordsui algorithm
ContextSpec is a UI framework providing a component model with pluggable backends. The current layouting options provide boxes, panes and grids.
GoalThe goal of this project is to develop a cassowary layout for Spec using existing constraint solvers. The student will need to define a DSL to describe constraints and define what are the minimal set of constraints components should have.
LevelAdvanced
CandidateTopic still free

TitleMaterial Design Lite
Emailcyril (a) ferlicot.me, guillaume.larcheveque (a) gmail.com and yannlesag (a) gmail.com
Supervisors Cyril Ferlicot-Delbecque, Guillaume Larchevêque and Yann Lesage
Keywordsmaterial design lite, material-ui, seaside, web, components
ContextMateria Design Lite (https://github.com/DuneSt/MaterialDesignLite) is a set of web components for the Seaside framework based on Google's Material Design guidelines.
GoalWe have multiple ideas to improve the project. (They are just ideas. Students can choose what they prefer) - Improve the brigde with the meta-description framework that is Magritte - Add new widgets such as TreeTables, Miller Columns, etc with tests and demos - Add functional tests with Parasol (Selenium integration for Seaside) - Creation of a tutorial on how to create a simple Seaside/MDL application - Writting of documentation - Improve integration of custom widgets with javascript - Integration with the Willow stack
LevelBeginner to Intermediate
CandidateTopic still free

TitleNext Generation Unit Testing
Emailguillermopolito@gmail.com, julien.delplanque@inria.fr
Supervisors Guillermo Polito, Julien Delplanque
Keywordsunit testing, parallelization, configuration
ContextSUnit is the current unit testing framework in Pharo. Building complex applications require new testing capabilities, with an enhanced UI and a clear API that allows new extensions.
GoalThe goal of this project is to redesign the SUnit framework to be extensible. The extension points and hooks in the framework should allow users to create their own extensions. Moreover, the student will implement extensions for common testing scenarios such as concurrency and parameterized tests.
LevelIntermediate
CandidateTopic still free

TitleHacking Pharo in Your Web Browser
Emailluc.fabresse@imt-lille-douai.fr, Damien.pollet@inria.fr
Supervisors Luc Fabresse, Damien Pollet
KeywordsDocker, Virtual machine
ContextThere is a need to be able to execute Pharo code through a web page. It implies sending code to the server-side for execution. However this execution should not expose the file system and machine resources. The idea of this problem is to run Pharo in a container and expose it in a web application. Such an isolated infrastructure could be useful for experimenting with Pharo trhough a Web page.
GoalPossible tasks are: - Have a look at http://www.tech.io / https://www.pythonanywhere.com / http://jupyter.org - Learn Docker - Make a first version - Build a little webfront end.
LevelIntermediate
CandidateTopic still free

TitleDependency Graph in the System Browser
Emailalexandre.bergel@me.com, akevalion@gmail.com
Supervisors Alexandre Bergel, Milton Mamani
KeywordsVisualization, Software Engineering, Roassal
ContextMaking the dependencies between software components explicit is known to be efficient at improving the quality of source code. Visualizations are commonly employed to represent dependencies between packages, classes, and methods.
GoalThis project is about embedding a visualization within Calypso, the Pharo code browser, that represents dependencies between projects, packages, classes, and methods.
LevelIntermediate
CandidateTopic still free

TitleBetter and more refactorings for Pharo
Emailchristophe.demarey@inria.fr, pablo.tesone@inria.fr, juampiboy@gmail.com
Supervisors Christophe Demarey, Pablo Tesone, Juan Pablo Sandoval A
KeywordsRefactoring IDE
ContextSmalltalk was the first environment to have such great refactorings that inspired a lot of languages and book authors. Unfortunately, refactoring support lowered in quality and some of them are now missing in Pharo.
GoalThe goal of this project is to provide Pharo developers a good refactoring support, comparable to modern IDEs like IDEA Intellij. See https://github.com/juliendelplanque/Enjoliveur/issues for a detailed list of tasks.
LevelBeginner
CandidateTopic still free

TitleSpec Debugging Tools
Emailguillermopolito@gmail.com tesonep@gmail.com
Supervisors Guillermo Polito, Pablo Tesone
Keywordsui debugging
ContextSpec is a UI framework providing a component model with pluggable backends. This makes sometimes difficult to understand the composition structure and go from the UI to the corresponding code.
GoalThe goal of this project is to develop several debugging facilities to help understanding Spec UIs. For example, click on a component and go to its code, highlight component boundaries on mouse over.
LevelBeginner
CandidateTopic still free

TitleNew Collections for Pharo
Emailjuampiboy@gmail.com, stephane.ducasse@inria.fr
Supervisors Juan Pablo Sandoval Alcocer, Stéphane Ducasse
KeywordsCollection DataStructure Benchmarks
ContextPharo contains a large set of collections (See http://books.pharo.org/ PharoByExample Collections chapter) with around 100 classes. But new collections exist such as BTree, QuadTree, SkipList, Trie, … Containers is an existing effort to gather many of the existing collection developed individually and externally to Pharo into a single umbrella. The idea is to create a modular collection library for Pharo users. Containers’s goals is to develop new efficient, well-tested, well documented collections. Containers contains already Tree, Grid, SkipList, LinkedList, OrderedDictionary but there is a need to revisit them. Finally Pharo 6.0 comes with two powerful primitives: new object immutability primitives as well as ephemerons [Hayes97]. With such important primitives two tasks can be performed: - design new weak collections taking advantage of ephemerons. - revisit and design new concurrent collections taking advantage of immutability. Links: - Camillo Bruni master contains a chapter on how to benchmark for collections http://scg.unibe.ch/archive/masters/Brun11a.pdf - http://source.lukas-renggli.ch/container started to implement some new collections for Pharo. - http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-851-advanced-data-structures-spring-2010/lecture-notes/
GoalTasks: - The student will study current Collections of Pharo (See http://books.pharo.org/ PharoByExample Collections chapter) for an overview. - He will study the new collections in the project named Containers on Smalltalkhub. http://smalltalkhub.com/#!/~StephaneDucasse/Containers - Migrate some existing projects to Containers (adding tests, comments). - Design and implement new collections such as -- BTree, QuadTrees, -- Immutable list, set, array Resources: - Camillo Bruni master contains a chapter on how to benchmark for collections http://scg.unibe.ch/archive/masters/Brun11a.pdf - http://source.lukas-renggli.ch/container started to implement some new collections for Pharo. - http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-851-advanced-data-structures-spring-2010/lecture-notes/ - Barry Hayes, Proceedings OOPSLA '97, ACM SIGPLAN Notices, Ephemerons: A new finalization mechanism, 1997
LevelAdvanced
CandidateTopic still free

TitleClosing the Loop
Emailstephan@legacycode.nl, christopher.fuhrman@etsmtl.ca
Supervisors Stephan Eggermont, Christopher Fuhrman
Keywordsdeprecations, adaptability
ContextPharo wants to be able to continue to change and adapt itself to an ever changing environment. In order to do that it needs to become more modular and make currently non-essential code easy to unload and reload on demand. With the in-system tests and CI there currently is a pretty good feedback loop telling Pharo developers when they break existing in-image code. That feedback loop is much weaker with external code. That code is often not developed in sync with the Pharo development. It is developed against a stable release or against the then current version of the development version. A lot of code is developed in student projects that don't have the continuity that Pharo itself has. Other code is developed for specific customers who are not interested in upgrading it. Even if there are sufficient tests and an automated build for that code, there often is not enough incentive and priority for it to be kept up to date. Achieving more adaptability and agility for Pharo can be found by making it easier to keep more code up to date, or by making it easier to bring removed code up to date again. This proposal is about the latter. When refactoring or rewriting some code, looking at the senders of a message and references to a class is one of the basic things to do to get a good understanding of how that code is actually used. Currently that only works in-image. When Pharo was a 32-bit environment that made sense, but with the current support for large images it should be possible to provide that information for all open source smalltalk code, and also to provide historic/version information for it. Some experiments have been done already to establish the viability: code (for older Pharo versions) is available on smalltalkhub: StephanEggermont/DeprecationFinder and StephanEggermont/MonticelloProjects
GoalAnalyze the source code of publicly available monticello/tonel packages and determine which classes and methods are used and defined by them (senders/references) (see DeprecationFinder). For Monticello use the history and deduplicate source code versions to reduce the amount of data that needs to be handled (see MonticelloProjects). Apply to projects on smalltalkhub and older repositories. Provide a api and a gui so Pharo developers can quickly access this information, and browse global and historic users.
Leveladvanced
CandidateTopic still free

TitleIceberg UI: Providing a commit graph visualization
Emailjuampiboy@gmail.com, guillermopolito@gmail.com
Supervisors Juan Pablo Sandoval Alcocer, Guillermo Polito
Keywordscommit, visualization, iceberg
ContextIceberg provides tools for handling git repositories directly from a Pharo Image. Besides the facilities provided by Iceberg, there is a lot room for improvement.
GoalThe goal of this project is to provide a commit graph visualization for improving the commit navigation and comparison, such the ones offered by popular git clients (i.e. GitKraken). Currently, there is a basic, commit graph visualization implemented called https://github.com/tinchodias/hiedra. However, there is many things we can improve on the visualization and the Iceberg UI. For instance, branch colors, filtering, scalability, and many other interactions.
LevelBeginner to Intermediate
CandidateTopic still free

TitleDataFrame
Emailolk.zaytsev@gmail.com, serge.stinckwich@gmail.com, philippeback@gmail.com
Supervisors Oleksandr Zaytsev, Serge Stinckwich, Philippe Back
KeywordsData Science, Data Analysis, DataFrame, Tabular Data, Statistics
ContextDataFrame was introduced to Pharo during the GSoC 2017 (https://github.com/PolyMathOrg/DataFrame). The work on DataFrame continued and many new features were introduced by different contributors. However, it is still a work in progress and a huge portion of functionality that can be found in other data frame packages (e.g. R, pandas) is missing.
GoalThe goal of this project is to introduce new functionality to DataFrame (for example, handling missing values) and write examples of applying DataFrame to real problems of Data Science (one can reproduce examples from pandas and scikit-learn documentation, as well as some examples from R-bloggers)
LevelBeginner or Intermediate
CandidateTopic still free

TitleSmartTest, a Test selection tool in a dynamically typed environment
Emailanne.etien@inria.fr,nicolas.anquetil@inria.fr
Supervisors Anne Etien, Nicolas Anquetil
KeywordsTest selection, Dynamic analysis, Static analysis
ContextCurrently in Pharo, when the developer modifies code, he/she has to know which tests may have been broken to run them or in doubt run all the tests of the class or the project. In that later case, it can be very long. We would like to introduce in Pharo a test selection tool to help the developer in his/her selection. We already developed SmartTest, such a tool, but it is not useable in practice, since it is too long and too intrusive.
GoalImplement some strategies to enhance the performance of the tool. Evaluate these strategies on real cases studies in an a posteriori experiment. Configure and tune the tool. Evaluate the tool on the field by taking advantage of the community. Put it in the Pharo 8 distribution.
LevelIntermediate
CandidateTopic still free

TitleNLP Library
Emailolk.zaytsev@gmail.com, alexandre.bergel@me.com
Supervisors Oleksandr Zaytsev, Alexandre Bergel
KeywordsNatural Language Processing, Statistics, Data Science
ContextOngoing research that is being done around analysing messages from Discord and letters from mailing lists, exploring commit messages, and performing static analysis of source code is based on simple but irreplaceable algorithms of natural language processing that tokenize text into words, perform stemming and lemmatization of words, count occurrences of words in text etc.
GoalWe need a natural language processing (NLP) library entirely written in Pharo with functionality similar to NLTK or Spacy: part of speech (PoS) tagging, named entity recognition (NER), lemmatization, stemming, word sense disambiguation, tf-idf, n-grams, various metrics etc.
LevelIntermediate or Advanced
CandidateTopic still free

TitlePharo Launcher command line interface
Emailguillermopolito@gmail.com, christophe.demarey@inria.fr
Supervisors Guillermo Polito, Christophe Demarey
Keywordsimage management, command line interface, virtualization
ContextThe pharo launcher is an application that allows the management of pharo images. In a "docker style", you can download images from templates, install them, list your installed images, and launch them. All this is done through a visual user interface in a desktop application.
GoalThe goal of this project is to implement a command line interface for the Pharo launcher, to be able to manipulate it on servers as we do with docker. For example: $ phlauncher list $ phlauncher templates $ phlauncher install X $ phlauncher run X
LevelIntermediate
CandidateTopic still free

TitleClasses and Methods for Spatial Data
Emailetienne.delay@cirad.fr serge.stinckwich@ird.fr
Supervisors Etienne Delay, Serge Stinckwich
Keywordsgeography, spatial data, spatial data manipulation, geographical grammar
ContextAs a title of "the economist" The world’s most valuable resource is no longer oil, but data. Nowadays data and especially geospatial data become central in our societies. Each one of us needs to be able to deal with data and spatial data.
GoalWe propose to explore structure to spatial data finding a way to load different types of geospatial data in Pharo. once the data is manipulable with our tools the goal is to develop some spatial method allowing for users to deal with spatial data. For that we will start from tools already existing in Pharo like the packages : Geometry, Shapes, geo-json and Territorial, but also in other programming languages (as R or python) in order to implement spatial methods for the community. The main objective will be first to be able to load a geojson file, to visualize it and to basic geometric operations.
LevelBeginner or Intermediate
CandidateTopic still free