Talks

Opening

Gabriela Arévalo

Conference Opening

Introduction to Lambda Calculus using Smalltalk

Facundo Javier Gelatti

It can be said that Lambda Calculus is the smallest universal programming language of the world. It consists of a single transformation rule (variable substitution) and a single function definition scheme. It was introduced by Alonzo Church in the 1930s as a way to formalizing the concept of effective computability. Since then, it has influenced many programming languages that we use today, including Smalltalk. Understanding the concepts defined in Lambda Calculus is not only interesting, but also important, because it encodes the basic principles of computing and programming, and it gives you another point of view from which to analyze the nature of computation. In this talk, I will introduce the concept of Lambda Calculus, and show you how some usual values and structures (such as booleans or pairs) can be implemented in Smalltalk using some of those concepts. The Lambda Calculus computation model can be approximated in Smalltalk by only allowing the definition and calling of one-argument blocks. For me, it was enlightening to see how booleans and other structures that I used every day were implemented in Smalltalk only by using objects and messages. I hope I can give that feeling back, by showing you how these concepts can be also implemented only using blocks.

Smalltalk blocks and closures: origin and evolution

Juan Escalada

Even though there probably isn't a Smalltalk developer who doesn't use Block on a daily basis, it's not common knowledge that they are based on the idea of Anonymous Functions, nor that their Closures' origins can be traced back to Scheme. The idea of this talk is to analyze the origin of this tool that defined Smalltalk, it's evolution until it became the full closure that we know today, and have a better idea of the potential advantages it provides.

A Smalltalk Patterns Safari

Brian Foote

Over the last 25 years, Design Patterns have become an integral part of day-to-day software development thinking. And, any casual inspection of the the seminal works in this area will quickly reveal the foundational role Smalltalk has played in the cultivation of these idea. This talk will examine that history by showcasing working examples of key design patterns, drawn straight from Smalltalk images, rather than set-piece toy examples.

A brief history of Smalltalk in Brussels

Theo D'Hondt

The value of commercial Smalltalk

Suzanne Fortman

In this talk, we will talk about promotional programs we offer, success stories when promoting Smalltalk usage and how they can become a business, how we connect graduates with companies using Smalltalk for jobs after education and the business side of Smalltalk.

Running Pharo on the Gemstone VM

James Foster

One of the features of traditional Smalltalk is that the development tools are in the same object space as the application being developed. A corollary is that it has generally been a challenge to debug a remote object space or build up a new class library from scratch. But GemStone's multi-user architecture provides some intriguing abilities to isolate not just classes, but methods. In this presentation we provide an introduction to GemStone/S and demonstrate running code from a Minimal-Pharo (with over 1400 classes) in GemStone.

VA Smalltalk Product Update and Roadmap

John O'Keefe

Pharo: a booming ecosystem

Esteban Lorenzano

Pharo has a yearly release cycle that brings each time interesting changes and does small steps to prepare the future. Pharo 6 was release in June 2017 and we are already preparing Pharo 7. In this talk, I will give an overview of current evolution of Pharo, where we are going and how we are working to construct a sustainable environment and an ever-growing community.

Winter: A Game Development Framework

Alvaro Piorno

The game development industry is not as big as web applications development, but is growing very fast all over the world. If you want to be a game developer or just develop some games, you must first decide what language you will use, because there is no solution for every language (at least not up to date or well maintained). The biggest solutions are Unity (C# , javascript and Boo) and Unreal Engine (C++). Other good solutions are LibGDX (Java) and PyGame (Python). So, if a Smalltalker wants to develop a game , they must select another language and adapt to that environment. Winter is a simple and fast to learn solution to this problem, so we can develop games using Smalltalk.

Willow 101: How to create an interactive web application

Gabriel Omar Cotelli & Maximiliano Tabacman

This talk presents Willow, a Web Interaction Library that provides all the components and tools to create an interactive AJAX-based web application, without leaving the comfort of your Smalltalk environment. After years of refinement and with a growing ecosystem of related projects, Willow is currently used by software development companies, personal commercial products and university research projects. We will review the most relevant features it offers, present a summary of the different web components and commands it reifies, and detail the open-source projects that make up this library.

Highcharts wrapper for Seaside

Mariano Martinez Peck

Highcharts is one the best and most used javascript charting libraries. The library provides a nice API with thousands of settings (options) at many different levels of the chart building. With the presence of that amount of flexibility, the needed javascript code is frequently too complex and painful to write and maintain from Seaside. In addition, when your chart is represented as a plain string, it is hard to use the tools we are used to: search for implementors, senders, reusability of components, etc etc. Furthermore, we also need to check their website all the time to see what each setting does. In this presentation, you will see a Smalltalk wrapper that solves the above issues. This wrapper, which is automatically generated from their API, provide us a much richer way of developing and maintaining charts. Aside from some real-case uses of the tool, this presentation also includes some interesting extensions worth showing.

Reasoning about memory-critical algorithms

Theo D'Hondt

Refactoring implementation for Cuis using TDD

Hernán Wilkinson

Cuis does not came with automatic refactorings due to a decision made by it's creator, Juan Vuletich, to avoid having more that one parser and one meta-model in the image, keeping the DRY principle. The refactoring implementation other Smalltalks provide is based on the Refactoring Browser. That implementation provides its own parser and meta-model because it supports different Smalltalk dialects. We thought that implementing automatic refactorings would be a very difficult task, but to our surprise it was simple and straight forward. We could do it with the current parser and meta-model and more importantly, we did it using TDD. We will show the process we followed and some improvements/differences with the Refactoring Browser implementation.

Replayable Refactorings

Juan Cruz Gardey

Reuse greatly streamlines development, but makes systems depend on the components they reuse. By components we mean frameworks, libraries or services, which may provide APIs to interact with them. These APIs change very frequently (methods change names, become obsolete, new appear new, etc.), which impacts on the programs that use them. The purpose of the work is to develop a solution to export changes to components in the form of refactorings, and then be able to reproduce them in the code that makes use of them, in order to automatically apply software updates. These automatic updates provide the advantage of reducing maintenance costs for both component developers and programmers that use them. We have constructed a tool in Pharo that allows recording and saving refactorings in the developers’ image, and lets programmers replay the refactorings in the target image. At replay, the tool first checks all refactorings’ preconditions in the target code and highlights unsafe refactorings together with the ones that depend on them for the user to inspect. Moreover, the tool allows users to discard refactorings from the replay list, which automatically checks dependencies with other refactorings using postconditions; in this way the tool always preserves a safe sequence of refactoring to replay.

Analyzing Software Evolution through MultiPile Matrix

Alison Fernandez Blanco

Relating software components, authors, versions along time is useful to support different software maintenance activities. However, few have been done to support these activities, making some of them difficult to carry out in practice. In this talk, we present MultiPile Matrix, an approach to visually explore software evolution in order to support a number of software maintenance tasks. MultiPileMatrix allows developers to analyze the relation between authors and versions along different time frames (i.e. months, days) MultiPileMatrix provides a domain-specific language to create custom visualizations and a friendly UI to use the default visualizations.

Experiences with the Universally Live Debugger

Boris Shingarov

The live nature of Smalltalk's development paradigm is among the most fundamental reasons of its effectiveness. Unfortunately, in some important cases this liveness gets in the way, for example when debugging low-level parts of the system on which the tools are themselves based. Another example is debugging-into-existence or testing of a partially constructed Smalltalk. Let alone working on the virtual machine itself: the VM programmer is left to use tools such as GDB which don't help in understanding complex VM/VI interactions. In a number of previous publications, this author introduced the "Universally-Live Smalltalk Debugger" based on executing the "inner VM" under control of a "mother Smalltalk" to achieve four benefits: (1) debugging of the low-level object engine within Smalltalk; (2) insight into interaction between the lowest levels of the system; (3) early integration testing and high-level debugging of incomplete software; and (4) realizing those advantages that may be offered by the underlying debugging server technology, such as reversability, bug transportation, or non-traditional performance metrics. In contrast to those previous publications which were focusing chiefly on the theoretical basis for ULD, this talk shows the actual experience of ULD's behavior in a matrix of different VM workloads (TAM, VLS) multiplied by different ISAs (PowerPC, AMD64, RISC-V) and different execution substrates (GEM5, OpenOCD, GDB). We hope to extend the discussion of ULD's application to the needs of the wider community.

VA ST 9: Exploring the next gen LLVM based virtual machine

Alexander Mitin

Instantiations recently released VA Smalltalk 9 which includes all new high-performance 32 and 64-bit virtual machines developed using the popular LLVM compiler infrastructure. This talk gives an overview of what LLVM is and provides a detailed look into the internals of how our LLVM-based virtual machine was implemented.

Dynamic Simulations

Leandro Caniglia

Smalltalk is the natural platform for developing products that perform simulations. In this talk I will discuss the key aspects of these kinds of systems.

Ephemerons: The Strong Path to Finalization

Martin McClure

Many applications need to finalize objects before they are garbage-collected. Smalltalk implementations have long provided weak containers as a way to address this need, but the newer ephemeron construct is becoming more widely available. Ephemerons are less well understood. What are ephemeron semantics, exactly? What are the differences (and similarities) between weak containers and ephemerons? What are the advantages and disadvantages? In this talk we'll take a look at these and other questions surrounding finalization, weakness, and ephemerons.

Run alone: a standalone application attempt

Gabriel Sor

How can we build an application in Pharo, that we can deliver to the final user, without UI, protecting the source code, and executed in just one click. In this talk I will present my experience in building a standalone application with Pharo, the drawbacks I found and all the ideas that it inspired.

Providing site and system admin tools within the application

Mariano Martinez Peck

Problems happen. And the quicker and easier you can address them, the better. Having a fully working environment to access your app server to analyze a problem, think of a solution or even apply a fix, takes quite some effort that we may not be willing to make in every situation. Whether you are a sys admin, a developer or a site manager/admin (an advanced user of the app), having tools on the web -- and even more, within the very same application -- does simplify, speed up and improve the experience of managing a production application. When the application is deployed in many different servers as different "instances", proving web tools becomes even more important. This presentation shows some of the typical maintenance tasks that could be provided from within the web app: web debugging errors, inspecting objects, evaluating scripts, profiling requests, etc. We also show a GemStone-specific admin console to see running gems, extent state, logs, backups, indexes, background processes, etc. The above list is not comprehensive of all things that could be allowed, but a good start to demonstrate the idea.

CuisUniversity and DenotativeObjects

Hernán Wilkinson

CuisUniversity is a customized version of Cuis that we are using to teach Object Oriented at the UBA and UNQ. We created that distribution to facilitate its installation and use by young students. It comes with Aconcagua, Chalten, Refactoring for Cuis and DenotativeObject. DenotativeObject is an environment to work with classless objects, a la Self, but using Smalltalk tools as the browser, workspace, inspector and debugger. We will show how the solution we adopted to have classless objects, how we implemented delegation, sharing, cloning and the like, how we customized the tools to work with classless objects and minimize the transition from those tools to the classic Smalltalk tools.

Evelyn: Evolutionary Learning Environment

Juan Pablo Mottesi & Julián Fischetti

Evolutionary Algorithms (EA) are based on biological evolution and used to solve optimization problems. Evelyn is a framework made to comprehend them and make it easier for the user to customize an EA and explore experimental results.

Reflection: Smalltalk’s Most Enduring Idea?

Brian Foote

It’s no secret that so many of the ideas that were incubated in the Smalltalk images and community a generation ago have had an influence on language design and programming technology in general that reaches far beyond that of Smalltalk itself. From objects themselves, first-class closures (think lambas), inheritance, dynamic types, virtual machines, and windowed GUIs, to name just a few, Smalltalk’s fingerprints are ubiquitous. Yet a case can be made that Smalltalk’s vision of a highly dynamic language built of objects themselves, able to manipulate metadata as easily as any other kind of data, has had a reach that has transformed the contemporary programming landscape in ways that might not be immediately evident. This talk will explore just how pervasive these ideas have become.

Pharo foreign function interface (FFI) by example

Esteban Lorenzano

Since Pharo 5 we have been developing a new framework for communicate with external libraries called UnifiedFFI (or UFFI) that has opened the doors to perform a huge step in our support for mainstream necessities. In this talk I will talk about the intrinsic problems of developing such frameworks and put it in practice through the example of the newest tool in the Pharo family: Iceberg (the git client).

Towards an improvement in the understanding of the operation of the interpreter of an object vm by means of a graphical tool

Mariano Badoglio & Patricia Fracchia

The following work is about a proposal to use a graphical tool as a didactical teaching on a complex topic like it is the Smalltalk Interpreter and how it works inside the virtual machine. The motivations arises on the need to arrive "otherwise" to the students. Its main contribution is that there is a theorical and methodological vacancy on this topic, regarding the didactical aspects, and its relation ith the teaching and learning processes. The main goal is to show the first steps in the analysis of the topic that will be applied to the cathedra "Programming Paradigms" placed on second year of the career Information Systems Engeneering at UTN-FRRo.

Metaphysics: reifying runtimes to be able to work

Javier Pimás

In this work, we experiment with adapting live programming tools to make them safer for the development of Bee Smalltalk, they can work on systems which crashed or that are not fully working. We will show Metaphysics, a framework that combines mirrors and proxies to reify different message execution semantics, allowing execution of code by mixing behavior of a remote, possibly broken system with a local fully-working one. With Metaphysics we were able to create native code debugging and profiling tools.

Automated Reasoning and the Behavior of the Smalltalk VM

Boris Shingarov

In practical engineering of the Smalltalk VMs in industrial use today, the "Just-in-Time" native compiler is programmed via one or another from of direct expression of machine-language program text output. As such, the execution engine definition is an entanglement of the VM programmer's intuition about what the bytecodes mean, with that person's intuition about what the machine instructions do. The reasoning about why the construct works is carried out informally in the programmer's head, and usually lost (discarded/forgotten) after the construct is written as source code; at best, we may be provided with a U-language remark in a comment. Attempting to address this problem, the author built two different n-code generators based on two independent principles. In the first approach, the machine automatically finds instruction sequences using a unification algorithm which matches formal definitions of bytecode semantics to formal definitions of processor instruction semantics. In other words, the n-code generator is automatically inferred from a formal processor description. In the second approach, the transformations leading from bytecode to machine code are specified by the human programmer, but the semantics of each representation language is specified with enough formal rigor to allow a mechanical proof of semantic preservation, carried out in an automatic theorem prover. In retrospect, it turns out that the two code generators are unexpectedly similar in fundamental operation. In this talk, we'll look at both and try to recognize some common principles which should be applicable universally to any effort towards rigorous Smalltalk execution engine construction.

The makings of Beenux (Bee for Linux)

Gerardo Richarte

This is an experience report on my somehow successful attempts to port Bee from Windows to Linux. I've followed some paths I've backtracked, and took some shortcuts with a clear direction. Taking an incremental constructive approach, the first milestone was gone and the next will be done probably at the time of the talk. The rest will probably be left as an exercise for the future .

Thin locks: featherweight synchronization also for Smalltalk

Jan Vrany

Traditional and still prevalent concurrency model is based on threads and shared mutable state. Smalltalk is no different in that respect, having processes that can run concurrently virtually "ever since". The traditional solution to prevent race condition is to use locks for synchronization. Many actions must be properly synchronized, even the simplest things like a Transcript or an access to a method source code. In this presentation I will talk about motivation, use and actual implementation of thinlocks - a fast locking mechanism invented for Java - in scope of Smalltalk.