Functional concepts in Smalltalk: The Y Combinator
The Y combinator (also sometimes called fixed-point combinator) is a function that can be used to implement simple recursion in languages where it is not possible to refer to the definition of a function from within itself (for example, in Lambda Calculus).
While most developers have heard about the Y combinator (at least as the name of an american company), it still remains as an arcane concept, considered very difficult to explain and understand. Most classical explanations are based on a deductive approach that is very difficult to reconcile with the way we think and the tools we use while we develop software (like unit tests or automated refactorings).
In this talk, I will introduce the concept of the Y combinator, and show how its implementation can be derived using Smalltalk.
Hashed Collections -- You Can (and sometimes should) Build Your Own
Hashed collections -- Sets, Dictionaries, and the like. We all use them, but sometimes the built-in ones don't quite fit our needs. We'll start by reviewing the concepts behind hashed collections. Martin will also tell stories of oddball collections he has implemented, discuss why you might want your own collection classes, and show how to create ones that perform well.
Glamorous Toolkit: Reshaping the Development eXperience
The Glamorous Toolkit (feenk.com/gt) aims to reshape the development experience. The first generation defined the notion of moldable development. In this talk we show how the second generation of the toolkit is another leap that creates a whole new experience:
- that supports humane assessment throughout the complete development
- that offers a live document engine that enable non-technical people to engage with technical content
- that unifies data science and software development in the same environment
- that supports example-driven development to bridge the gap between testing and documentation and to capture stories about our systems.
Lessons learned implementing refactorings
Cuis Smalltalk does not have the refactoring tools that other Smalltalks provide. This pushed me to implement automatic refactorings for Cuis from scratch which allowed me to take different approaches to the Refactoring Browser implementation, the one all Smalltalks used as starting point. On this presentation I'll show these approaches and some lessons learned in the process of it implementation.
The Dynabook as a tool for Research and Development
Software is usually seen as the means to solve a problem by computer. Science is usually seen as a buildup of knowledge that can be mined for ideas to solve problems. Keeping Software Development and Scientific Research as two separated activities limits the quality of the former and the applicability of the latter. We describe an approach to scientific research and software development that builds on the ideas and practices of Experimental Mathematics, and best practices in Software Development, and results in an integrated process and tools. The result is a body of knowledge that satisfies the requirements to be considered serious research, and provides useful building blocks for real world software applications.
Lázaro: the Smalltalk screen reader
Matías Melendi, Angeles Tella Arena
All the Squeak-like implementations of Smalltalk are built as rendered environments inside an image, therefore, they don't use the native visual components of the operating system to build the user interface. This particular attribute makes them incompatible with native screen readers.
Lázaro is an application built in Smalltalk that helps blind people use Pharo connecting the image with text to speech synthesizers (TTS) in the operating system.
Animations and Native Deployment for games in Winter
Winter (2D game development framework) was presented last year in in an early stage of development, this year it bring us some new features.
It comes with some new architecture changes, but also 2 new important features: Animations and Native Deployment.
Application Development and IoT with VA Smalltalk
Mariano Martinez Peck
Mariano Martinez Peck, from Instantiations will demonstrate real world application development using VA Smalltalk. This demonstration will touch on topics such as an advanced code editor, configuration management with ENVY, code coverage and metrics, performance and memory profiling, remote debugging, cross-development packaging, image reduction capability and more. Finally, he will show how these topics can be a game changer in the IoT field.
Denotative Objects are growing fast!
Last year we presented CuisUniversity and DenotativeObjects, now we have more features we would like to show: delegation, different cloning techniques, transition from concrete objects to classes, refactorings, didactic improvements to tools, and even graphical denotative objects. Everything in constant evolution as we use them in different universities. Also we'll see how easy is to inspect and modify Cuis to introduce a change!
Building native Android apps with s8
Felipe Zak, Alejandro Reimondo
Present a development cycle for building native Android apps with s8. An example app is provided, U8 Tools: A complete Smalltalk environment running in your device as an Android native application.Including Smalltalk toolset (browser, workspace, inspector, references, transcript...).
Willow, the interaction tour
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 focus on presenting the user interaction affordances, while also showcasing its features and the most relevant reifications for web commands and components.
Manipulating live documents with Documenter
Documenter is the Glamorous Toolkit tool for creating and consuming live documents directly in the development environment. This session shows concrete examples of how it can support multiple scenarios: code documentation, tutorials, and interactive data notebook.
Deviation Testing: A Test Case Generation Technique for GraphQL APIs
Daniela Meneses Vargas, Andreina Cota Vidaurre
GraphQL is a flexible and expressive query language. With the objective to replace the flawed and inefficient REST architectural style, GraphQL has been adopted by numerous online APIs and services. Despite its popularity, testing theimplementation of a GraphQL schema is a crucial and still an open problem.
We found that classical techniques of test generation may be efficiently applied to GraphQL server. We propose a simple but expressive technique called deviation testing that automatically searches for anomalies in the way a schema is served. We demonstrate the feasibility of our approach using an implementation of GraphQL for Pharo and VisualWorks. Running our technique on the popular Yelp and Apollo GraphQL server uncovered several anomalies in the way the schema is served.
Blockchain and decentralized architectures
In 2008 a paper published by a pseudonymous author named Satoshi Nakamoto introduced Bitcoin as the first pure peer-to-peer electronic money that didn't require intermediate institutions to work.
To achieve such feat the author synthesized different technologies and ideas and defined new ones that became the building blocks to create new decentralized systems. Since then a new wave of applications and organizations was set in motion and it is growing on a daily basis.
This talk want to spread awareness about cryptocurrencies, blockchain and related ideas because of its general relevance and because Smalltalk, both as a technology and as a community, can use this opportunity to show its strengths and raise its public visibility.
Examples are somewhat like tests that return objects. This apparent small change can have deep implications on development. In this session we provide a hands-on experience of developing driven by examples, and outline the implications and economic gains of designing our tests to also be examples for our systems.
BA-ST project ecosystem
With a group of like-minded and like-located smalltalkers, we have created the Github group "Buenos Aires Smalltalk" (BA-ST for short).
In it we have been sharing a set of interconnected projects, that would allow many of the architectural challenges of current applications to be available from the start.
You already know about Willow, but there are others. This talk will present an overview of some of these projects and what you can do with them, from configuring a new Github project, to working with graphs, state machines, systems and model creation, to name a few.
VM programming for everybody
Traditional Smalltalks are implemented in to of a static VM that implemented basic features like method dispatch, garbage collection and primitives. Instead of that, Bee DMR (dynamic metacircular runtime) implements everything in Smalltalk. This makes it simpler for Smalltalkers to understand how the entire system works. Now that Bee is open source, we are doing a hands on tutorial on how to inspect, debug and modify the parts of the runtime that replace the ones found in traditional VMs
Using system-level tools to debug smalltalk systems
Smalltalk environments are traditionally praised for their debugging features based on runtime reflection. However, some kinds of problems are difficult - if not impossible - to debug using traditional Smalltalk in-process tools such as debuggers or inspectors. To name some: crashes in external libraries called via faulty runtime of FFI, heap corruption, race conditions.
In this talk I'll demonstrate that using system-level tools such as GDB to debug smalltalk may be as easy as using traditional smalltalk in-process debugger. Maybe even easier...
Travels with RISC-V
The free instruction set RISC-V, which has reached the momentum to be the clear candidate for the defining ISA of the next decade, presents a number of unique opportunities for Smalltalk. One, there is a vacuum for dynamic runtimes. Two, there is a shift in design objectives accepted by the community. For example, whereas we used to be content with intuitive suggestions for why a particular sequence of CPU instructions may work, today's customers demand formal verification of their whole software/hardware stacks. The definition of "performance" is undergoing equally large changes.
Two experimental Smalltalk VMs -- TAM and VLS -- are designed to enable exploration of these challenges. This talk presents these VMs running on real RISC-V hardware, yielding a number of unexpected differences with the more conventional CPUs.
Dynamic type information generation
Smalltalk, as any dynamic typed language, lacks type information that statically typed languages have. Despite some performance hit due to this characteristic, it degrades the accuracy of some tools like automatic refactoring, code browsing, type checking, etc.
But Smalltalk is a running environment, something that it deeply differenciate it from other dynamically typed languages. Sadly, we are not taking advantage of this important characteristic to generate type information dynamically.
In this presentation I will show a small change to the OpenSmalltalk-VM that keeps type information for instance variables and how this information helps the tools.
On going ideas and challenges of a complete implementation will be discuss