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?".
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.
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.
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.
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.
Stargate, an interstellar journey to RESTful APIs
by Juan Escalada
This talk will present [Stargate](htts://github.com/ba-st/Stargate), 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.