Day 1


by Maximiliano Tabacman

Diagnosing bad TDD habits with Dr. TDD

by Nicolás Papagna Maldonado

Test-Driven Development (TDD) is a technique that helps developing software in an iterative and incremental way with a strong emphasis on immediate feedback. Though simple at first sight, it challenges students since it implies a strong cultural change in software development.

In this talk, I will present Dr. TDD, a real-time advisor that aims to give immediate feedback (in the same spirit as TDD) to students about how well they know and apply this technique together with recommendations to correct deviations from it.

I will also show how a live programming environment provides an excellent canvas for developing it, a few implementation details and some interesting findings about what happens when we deviate from the red-green-refactor cycle.

Finally, I'll go over some of the common mistakes made while practicing TDD, how severe they are, and how Dr. TDD helps you fixing and preventing them.

As a bonus, I'll comment on my experience using Dr. TDD to develop the tool itself.

Threads, Critical Sections, and Termination

by Martin McClure

Correctness of a multi-threaded program is much more difficult to achieve than correctness of a single-threaded program, but in some situations we can't avoid using more than one thread, and therefore have to deal with the resulting complexity. In this talk, Martin will present some of the threading problems he's seen and solutions to those problems, with a focus on the additional problems that arise when threads are terminated.

Smalltalk Computers, Past and Future

by Jecel Mattos de Assumpção Jr

Alan's Kay FlexMachine thesis was a mix of hardware and software, as was the Dynabook idea. This was quickly followed by the Xerox Alto computer and then the D machines. Smalltalk-80 first became commercially available in the form of the Tektronix 4404 AI Workstation hardware and there were several academic Smalltalk hardware designs such as SOAR (Smalltalk On A RISC, retroactively renamed as RISC III to justify the RISC V name) from Berkeley, the Mushroom from Manchester and the 1024 processor J-Machine from MIT. Only with the introduction of Digitalk's Methods (later Smalltalk V) for the PC and ParcPlace's Smalltalk-80 for workstations did the language become a software-only product.

Jecel started his 68000 based Merlin 1 Smalltalk computer project in 1984 and did several designs with commercial processor before moving on to his own Smalltalk specific processors in 1998. The current SiliconSqueak project and future research directions will be described in the context of the history mentioned above.

The Roassal3 Visualization Engine

by Milton Mamani Torres

Roassal2, born 6 years ago, has become a standard in data and software visualizations in Smalltalk.

For nearly two years we have developed Roassal3, a new visualization engine. Roassal3 features amazing animations and a rich set of intuitive interactions. This presentation our past and future effort on redesigning and improving a standard in the Smalltalk community.

Constructing 3D scenes with Woden Engine

by Ronie Salgado

This talk is about how we can use Pharo to construct visually impressive scenarios in 3D, which can be used to expose an idea, or just with entertainment purposes. This talks introduces the concepts of utilizing externally made 3D, and the usage of PBR materials that follow the modern lighting model that was created by Disney, and standardized by Epic Games in Unreal Engine 4, and nowadays is the de-facto standard in films and real time graphics. We follow by introducing visual elements completely generated by scripting code in Pharo to the scene where we combine data visualization with art. We finish this presentation by demonstrating the different ways of interaction that can scripted and utilized with a fully constructed 3D scene in Woden Engine.

Improving VASmalltalk deployment, availability and scalability with docker

by Mariano Martinez Peck

Anyone that has ever done a deployment with Smalltalk knows how easy it can be compared to other languages. But the technology space is always in motion and with a continued increase in DevOps roles, the rest of the world offers top notch technologies for improving deployment, availability, scalability, and other aspects of the whole software engineering process.

In this talk, I will show how VA Smalltalk integrates smoothly with these technologies to build enterprise-class scalable and performant systems. I will demonstrate how to take an application from the development environment and prepare it for deployment. I will show how to get started with Docker by building Docker images and running them within isolated containers. Finally, I will create an ARM 64 cluster using Raspberry Pi and a Pine64 IoT devices that will be running a cloud of containers: a Docker Swarm.

Desmitificando la creación de herramientas para manipular CODIGO (In Spanish)

by Facundo Javier Gelatti

One of the changes of perspective that one usually has while working with Smalltalk is to start thinking about code as a living organism. In other words, the code goes beyond of being an array of characters, and becomes a dynamic object of study, that one can inspect and manipulate. Additionally, as the code of the system is available to be explored and modified, developers are encouraged to build their own tools to help with their work.

In this talk, we're going to explore the basic concepts needed to start developing tools to manipulate and inspect code, guided by a practical example. We're going to see different ways in which code can be represented, and answer questions such as "what is an AST?" or "how can I develop a tool that helps me work with code?".

Machine Learning in Pharo

by Serge Stinckwich

We will demonstrate how this is possible to do machine learning with TensorFlow and Pharo.

PythonBridge, poniendo el catalogo Pypi al servicio de Smalltalk (IN SPANISH)

by Milton Mamani Torres

PythonBridge es un software que permite utilizar software desarrollado en Python desde una imagen Smalltalk. La comunidad Smalltalk realiza muchas contribuciones, pero no posee la cantidad de gente y recursos para reinventar y replicar todas las librerías y frameworks de interés implementadas en otros lenguajes como Python. El objetivo de PythonBridge es poder utilizar fácilmente cualquier librería Python desde Smalltalk, permitiendo a todo Smalltalker aprovechar el vasto ecosistema que posee Python. Todo esto desde la comodidad de nuestra imagen Smalltalk.


Executing the Smalltalk VM Algebraically

by Boris Shingarov

Traditionally, software developers validate their software to ensure absence of programming errors using the approach called testing. In a test, we execute the software program giving it a test vector as input, and observe its behaviour. If the program behaves correctly on each test vector we test it with, we deem that it appears to work. Unfortunately, testing says nothing about those inputs that are not in the set of the tested vectors, leaving us with the problem of latent bugs.

Latent bugs in compilers present an even more difficult problem. Due to the level of abstraction compilers operate at, these bugs often hide for longer, are more subtle, may manifest in a crash only billions of CPU instructions after the bug’s true cause, and are generally more difficult to isolate than bugs in other software.

This talk is a major update on the author's approach to solving this problem for the Smalltalk VM which is based on formalizing the VM in a logic suitable for mechanical proof. The new system is similar to the one presented at this conference in previous years in that the Just-in-Time code generator is inferred from a SystemC-level structural description of the processor. The new contribution is that now the guarantee of correctness is obtained via representing all data processed by the JIT as variables in a computer algebra. The crucial idea is that it allows to reverse the order of code-generation steps: in particular, to perform instruction encoding before all parts of the instruction are known.

This results in instruction memory with "holes", i.e. bit-regions specified algebraically. This kind of binary code can be executed on a symbolic CPU (such virtual CPUs have become popular and widely available in the formal methods community in the last decade). Tests become formal checks: we prove "Test Successful" valid under universally-quantified test vector using refutational style -- i.e. by trying to find a counterexample: if the search for counterexample fails, this means that our proof succeeds.

This technique has been well-established in the verification of static compilers. (Lopes et al.'s ALIVE system for proving optimizations in LLVM, and Shoshitaishvili et al.'s ANGR binary analysis tool, are two examples). Unfortunately, those existing systems fail in the presence of self-modifying code typical of dynamic compilers such as any Smalltalk JIT. The present contribution fills this gap.

In this talk, we will step -- in the Smalltalk debugger -- through the proof of one simple JIT translation. In this demo there will be no arcane mathematics -- it's all plain Smalltalk.

Adaptive Compilation

by Jecel Mattos de Assumpção Jr

Traditional language implementations are interpreters and compilers, though it is possible to mix them: compiling source text to some bytecode which is then interpreted, for example. The performance of a hybrid system can be much greater by also compiling the bytecode to native machine language dynamically, which is known as JIT (Just In Time) compilation. The problem with this is that the compiler now has to do its job really fast because it is getting in the way of executing the actual application code.

Most of the time is spent executing a tiny fraction of the code, known as the hot spots. An adaptive compiler can quickly generate usable code for the common case and then dedicate a lot more time doing a better job on the hot spots for a better overall performance. Such a system has unique advantages and complexities.

Powerlang: a Vehicle for Lively Implementing Programming LANGUAGES

by Javier Pimás

Developing a programming language from scratch, with a stable and yet efficient runtime environment could be considered a titanic task. To mitigate this situation, and promote the early emergence of new languages, two main alternatives have been proposed: adopt an established virtual machine or exploit meta-compilation frameworks. In addition, micro VMs have been proposed as a foundation for developing VMs on top of a thin layer of abstraction similar to the micro kernel concept proposed for operating systems. Each of these approaches represents a compromise solving the tensions between flexibility, correctness, efficiency, and effort when designing a language runtime. Accordingly, each approach exposes its benefits while still suffers from limitations.

The Bee development team has been developing a complete Smalltalk system for more than a decade. During the journey, we implemented several artifacts needed to build a virtual machine: parsers, compilers, assemblers, bootstrapping utilities, (native code) debuggers, remote execution protocols, simulation tools, and garbage collection algorithms, among others. After weighting all the different paths followed during these years, in this talk we advocate for a novel approach for building language runtimes. Concretely, we envision Powerlang, a framework that would enable to design, debug, inspect, compile, optimize, and test new programming languages, with a moderate effort and significant versatility. Powerlang represents a novel point in the design space of this kind of solutions. Finally, Powerlang is developed using a live environment like Smalltalk.

Doing Math & Science in Pharo with PolyMath

by Serge Stinckwich

We will present the last development of PolyMath, an open-source numerical computing library based on Pharo Smalltalk. The framework will be demonstrated with examples on how to use PCA and t-SNE. PolyMath include DataFrame, a data science framework build by Olekskandr Zaytsev.

What is not new in Pharo 8?

by Pablo Tesone

This talk will give an overview of the different elements happening in Pharo. It will also report the state of the consortium. The roadmap for Pharo 8.0 and Pharo 9.0 will be discussed.

Pharo 8 is coming with a lot of improvements and new features.

We will present the set of tools & technologies that we are introducing in Pharo 8 and where we want to get with Pharo 9.

A small non-exhaustive list:

  • Spec v2.0
  • Dr Test
  • Gtk Support
  • Threaded FFI
  • SDL / GTK visual backend.
  • Improvements in Refactorings
  • Improvements in Performance
  • Better integration with Windows
  • Better customization
  • A complete bootstrapped system!
  • More modular!
  • Improved Debugger

VA Smalltalk Product Update

by Seth Berman

Instantiations is continuing to invest heavily in the VAST (VA Smalltalk) Platform, used in mission critical software for both small companies and enterprise-grade applications across the globe. This talk will focus on defining our mission at Instantiations, as well as presenting some of the features that will be landing this year in our next release: VA Smalltalk 9.2.

Cuis Smalltalk - Past, Present and Future

by Hernán Wilkinson & Juan Vuletich

Cuis is a modern implementation of Smalltalk 80. It runs on the OpenSmalltalk COG VM. It has a big, active and dynamic community and it is growing in features, projects and functionality.We will talk about the many active research and development projects done by the community, and briefly demo some of them.At the end we will talk about the next steps and ideas for the future.

Application Starter: the entry point for your application

by Inés Sosa

Application Starter is a tool designed to be the entry point of an application written in Pharo.

Why is VASmalltalk a great possibility for doing IoT and edge COMPUTING?

by Mariano Martinez Peck

Interest in the IoT space continues to expand, specifically in the enterprise space where the requirements of stability, security and performance are far different than that of the hobbyist. The hardware has improved to the point that small IoT devices are not just being limited in scope to the collection of data. These devices now have ample processing power to apply business logic and process the data before being sent out to storage locations like the cloud.

In this talk I will answer: Why is Smalltalk a good fit for IoT and edge computing? Does it have unique features over other languages? How would IoT benefit from Smalltalk?

I will show why VASmalltalk in particular is a great choice for IoT and edge computing by showing some specific applicable features: cross development, bootstrapped and reduced images, remote debugging, true headless VM, multiple CPU architecture support (ARM, aarch64) , ARM JIT compiler, transparent GemStone persistency, and different kinds of sensors with different protocols (1-Wire, I2C, etc) etc.


coordinated by Gastón Caruso

Diverse short five minutes talks


Choosing where to run our objects: the S8 Smalltalk approach

by Felipe Gabriel Zak

Examples of S8 systems running on top of different executions machineries and platform combinations are shown, as well as interactions between those S8 systems.

Some of S8 Smalltalk general approach is also outlined.

Enhanced Email Protocol Framework for VAST

by Seth Berman

VA Smalltalk 9.2 will introduce all new IMAP and SMTP client protocol implementations with an exhaustive set of supported features including SSL/TLS, Compression, IDLE (aka Server Push) and much more with combined support of more than 20 implemented RFCs. In this talk, I will be giving an overview of this new and powerful email framework.

Improving the Pharo VM

by Pablo Tesone

Last year the Pharo team set as objective to have a headless event-based embeddable VM for the future.

However, evolving the VM and reaching a mature product requires an infrastructure that supports change and makes it painless.

One year later, we have make good progress with our infrastructure, which lead us to a first version of a headless embeddable VM.

In this talk, although the VM seems to be the subject, we want to focus on the scaffolding around it:

  • A simpler build process using CMake and integrating with existing IDEs,
  • Making Slang work back in Pharo, taking advantage of our set of tools,
  • Automated tests to detect regressions in Slang generation and VM execution,
  • Automated benchmarks to detect performance regressions,
  • and a CI to govern them all

These changes were capital to make possible this year:

  • a headless VM suited for server applications,
  • an embeddable VM to spread Pharo in other applications,
  • a reorganization of VM plugins to strip VM footprint,

Although our short-term future includes an event-based VM, this infrastructure opens a lots of doors in VM development.

We have been working towards an event based VM with a better FFI interaction and smaller CPU footprint, it is intended to be customizable and easily modifiable.

This talk will not only about the things we can do for the VM, but how to integrate the community and improve the quality and quantity of the VM work.

Cuis Web

by Gastón Caruso

Cuis web is a framework to create web applications using Cuis Smalltalk, it is the result of a work for Bioinformatics lab at UNQ.

Stargate, an interstellar journey to RESTful APIs

by Juan Escalada

This talk will present [Stargate](htts://, a library supporting the creation of HTTP based RESTful APIs.

The library is built on top of Teapot and Zinc, providing a conceptual framework to simplify the creation of RESTful APIs including HATEOAS, content negotiation, API versioning, ETags and pagination.

We will revisit the library affordances and a real world experience report using it.

Development of modern information systems with Smalltalk

by Alejandro Fabian Reimondo

Smalltalk has been used for +30 years now. Changes in the world of software development produced multiple visions on how/why to produce virtual object systems. The original design and vision of Smalltalk is elegant but not enough to move smalltalk objects to new media as fast as new execution environments became available. S8 vision, habits and frameworks will be presented in order to spread our objects using S8 Smalltalk on diverse execution environments.

OOP with Smalltalk in the UNComahue

by Nadina Martinez Carod, Silvia Amaro, Natalia Elizabet Baeza

For more than 15 years we have instructed students to learn OOP using Smalltalk, mainly in concepts such as encapsulation, abstraction, inheritance, and polymorphism. At the end of the course, students are able to identify advantages in terms of reusability, creating and implementing simple solutions for typical problems. This is possible because of the characteristics and nature of this pure OO language and we choose it because we consider it the best way to start learning thinking differently.

However, students usually present some difficulties when they start thinking in this new paradigm. After this first difficult step that they have to pass through, they finally get a whole idea about what OOP is, how and when they could use it. We use simple examples and typical problems by identifying implementation differences between different OO programming languages.

This talk explains our experience from a lecturer's point of view and shows some examples about what they are able to do during the OOP course for the Computer Science degree careers in the UNComahue. It also explains briefly what is the OOP related knowledge the University guarantee the students acquired during the Bachelor.

Tonel repositories in VA Smalltalk

by Esteban Maringolo

Tonel is the baseline format used by Pharo for file based source code storage. As such, it was developed considering only Pharo needs.

This talk is a report of the challenges and workarounds found to support exporting and importing Tonel based repositories in VA Smalltalk, and dialect differences in general.

.NET interoperability with Smalltalk

by Carlos E. Ferro

Some examples of using .NET libraries from Smalltalk code will be shown. We will explain how the bridge code for invocations is automatically generated. We can also explore some implementation details and explain the COM layer intervening in this magic.

Live Typing -Update & what's next

by Hernán Wilkinson

Last year I presented Live Typing, a new idea about annotating types in Smalltalk. There have been a lot of improvements and new functionality has been added to it. I'll present them and show what is coming up.