Madrid Smalltalk User Group Meeting on Pharo - 29. April 2019

Nueva reunión del meetup de Madrid Smalltalk el lunes 29/4: "Taller sobre Moldable Development en Pharo". Read more here

Pharo Sprint April 26

Read https://association.pharo.org/event-3253846 for more details.

Moose for Pharo 7

is now available. Check the webpage:

http://moosetechnology.org

Type Checking Pharo methods

Manuel Leuenberger reported that he improved performance on his type checker for GT Tools.

Code is here: https://github.com/maenu/gtoolkit-contribution-typer

I wonder if it would work also without GT / Bloc / Brick and could be used already in a standard out of the box Pharo image...

Geranium

Geranium is an Energy consumption simulator for participatory modelling and decision making, taking into account: urban, social and micro-climate data. It is written in Pharo available on github on

https://github.com/npapoylias/Geranium

They are currently looking for a Pharo Developer for 4 months, based in La Rochelle France. Check the jobs channel on Pharo Discord if you are interested. Or check here.

Pharo and native UIs - from Mars to Spec

Pharo 7 (beside many other features) was focused on being able to bootstrap an image right from the source as well as the transition to using git. Also stabilizing Iceberg tool with Git binding to have an improved source code management and give Pharo and its source code more exposure to the outside non-Smalltalk world.


Now Pharo 8 (which is currently in development) will focus on an updated version of Spec called "Spec 2.0". To build abstractions and prove that other backends (beside Morphic) could be used there is a plan to have a GTK binding as a second backend. This goes back to the old "Mars" project from Esteban - a native user interface framework which aimed to bring the native UI into Pharo. If I remember correctly back at the time it used an ObjectiveC Bridge.

This was already discussed on PharoDays 2019 and now Esteban gives some more detailed infos about the background on the Pharo mailinglist.

Workflow engine written in Pharo

In 2017 Netstyle open sourced a workflow engine for Pharo. I reported about this here.

Now in 2019 there is another Workflow engine written in Pharo from Sebastijan Kaplar:

    https://github.com/skaplar/NewWave


Still in early development. But you can also join if you like

Data Analysis of UCI Heart Disease Dataset using Pharo

Data Analysis of UCI Heart Disease Dataset using Pharo - a short tutorial by Dhanya Sreekumar

Why I Talk About Smalltalk Even Though I’m Working in Java

Interesting medium.com article from Andrew Glynn called "Why I Talk About Smalltalk Even Though I’m Working in Java"

Hunter: a JavaScript reengineering platform based on Pharo

Hunter: a JavaScript reengineering platform based on Pharo is available on 

          https://github.com/dorellang/hunter


 

Pharo language track on exercism.io

An exercism.io language track for Pharo can be found here:  https://exercism.io/my/tracks/pharo-smalltalk

Pharo DataFrame v2.0

Pharo DataFrame release v2.0 is available: 

 https://github.com/PolyMathOrg/DataFrame/releases/tag/v2.0

Read here what it can do for you.

Pharo graphics using Roassal

Milton shows some nice graphics examples on his twitter stream (using Pharo and Roassal): 

https://twitter.com/akevalion

Pharo Newsletter April 2019

Pharo Newsletters for each month are available at:  http://newsletter.pharo.org

PharoDays 2019 in Lille

Some impressions from Pharo Days 2019 in Lille

https://gopro.com/v/rD5G5reVmG9pd

Debugger driven development in Pharo

Some work Vincent Blondeau and Stephan Eggermont have been doing on the Taskbar have inspired Stephan me to make some screencasts showing how to do debugger driven development, and take the first steps towards refactoring the TaskBarMorph in Pharo, driven by tests.

• Part 1 https://vimeo.com/329317634 
• Part 2 https://vimeo.com/329368348

ComputedSlots in Pharo

In Pharo 8 it is now possible to use ComputedSlots. Beside the regular instance variable (slots) we add a computed slot with a block.

Let's assume I would like to implement a Person class with a name and firstName but also get a fullName.

Object subclass: #Person
 slots: { #name. #firstName. #fullName => ComputedSlot with: [ :obj | obj firstName asString , ' ' , obj name asString ] }
 classVariables: {  }
 package: 'Simple-Example'

so when you test

 
|p|
p := Person new.
p name: 'Adams'.
p firstName: 'Douglas'.
p fullName 
 

it would return the full name 'Douglas Adams'.

When you now add an additional class side method #firstName:name: like

firstName: firstName lastName: lastName

 ^(self new)
  firstName: firstName;
  name: lastName;
  yourself

you can simply write with our small english like DSL:

 (Person firstName: 'Douglas' lastName: 'Adams') fullName

to get the same result.

For sure we could have implement the getter method #fullName like this:

fullName

 ^self firstName asString , ' ' , self name asString

to achieve the same - but a computed slot shows up really in the inspector as if it would be a real variable and is recomputed if you for instance would change the name or firstName.

Running Pharo in Windows Subsystem for Linux (WSL)

Is described here: https://fuhrmanator.github.io/Pharo-in-WSL/

Continuous delivery with GT Releaser

new article on GT Releaser tool.

Future of Coding about Moldable Development

Interview of Tudor Girba in a podcast on "Future of Coding"

   https://futureofcoding.org/episodes/036

v2.1.0 Material Design Lite for Seaside

New version v2.1.0 is available now. Check it here.

Glamorous Toolkit v0.5.1

is out now - and it is based on latest Pharo 7.

Reactive data bindings framework for Pharo

A small Vue.js-inspired reactive data bindings framework for Pharo.

Registration for Pharo Days 2019 open

Just check this page if you want to participate.

New (bugfix) release of PetitParser v2.1.2

is available here.

Marvin

Marvin - a Prototype system based on Self for Pharo from Pavel.

P3 V1.2 - PostgreSQL client for Pharo

A new release 1.2 of P3, the modern, lean and mean PostgreSQL client for Pharo.

ObservableSlots for Pharo

A language extension for Pharo to have slots that announce changes. This is useful expecially in UI projects.

   https://github.com/guillep/ObservableSlots

The computational notebook of the future

This screencast shows an idea of how computational notebooks should work in the future. For pointers to the technologies being used, see the accompanying blog post

TravisCI and Smalltalk

SmalltalkCI was integrated with Travis. To set up continuous integration for your Smalltalk project, you need a .travis.yml and a .ston configuration file for SmalltalkCI. It is easy to setup and works great in many Squeak and Pharo projects already. Read the docu for more.

Pharo 7.0 released

Smalltalk systems influenced computing like no other technology in the world. You will find many of its ideas in all modern software systems ranging from graphical user interfaces up to mobile devices.

With Pharo-Project we continue with this tradition to provide an inspiring lively object-oriented system but also move Smalltalks ideas to the next level.

Today is the day we release Pharo 7.0 into the wild and again as a free open source gift to the world.

This is yet another major step towards a brighter future for dynamic development approaches. Pharo 7.0 was realized by a worldwide community of 75 people - taking us over one year of distributed development.

Pharo advanced on many sides. Now we can fully bootstrap into a custom image - including Slots, Metalinks and other meta facilities. New books and tutorials were written about it, it is used in web development, IoT and other. It's already a business driver for several companies worldwide with a growing number of users.

2142 issues solved in general - 762 commits done from my side (astares) alone. Mostly trivial stuff but each still important to cleanup and form a well structured core. Dont know if I could be proud to have climbed to the top in github contribution statistics in this release - personally I will remember the PR's primary as 762 times fighting with the CI infrastructure ;)

Pharo 8 work already started now ... so come in - the water is just fine. Step by step it goes...

Dispatching tasks to multiple Pharo VMs using SystemProcess

is described here.

MachineLearning in #Pharo

Want to check out MachineLearning in Pharo? Then use this awesome list of projects, books, booklets, papers, and applications related to machine learning, AI, data science in Pharo

Releaser

Releaser is a new tool for releasing nested #pharo projects residing in multiple repositories. Read more.

TimeMachine in Pharo

Funny experiment of Manuel Leuenberger about using Bloc and Pharo to get a déjà vu

Glamorous Toolkit v0.4.0

Glamorous Toolkit v0.4.0 is out. Read more.

Maizo and Pharo

Maizo - a Chemistry project developed with Pharo.

To quote research gate:

Maizo is aimed toward molecular- and reaction discovery based on big data of quantum mechanical global reaction route mappings. The global reaction data includes equilibrium structures (EQs), dissociation channels (DCs), and transition structures (TSs), which are automatically calculated by a global search on a potential energy surface using the GRRM (global reaction route mapping) method. Applications to molecular- and synthesis design are an important part of the project. Machine learning and visualization techniques as well as chemoinformatics methods are essential to acquire useful information from the large reaction data space. The team developed an RMapViewer, which was developed to visualize and analyze the GRRM outputs.  

Read the PDF on "Maizo"-chemistry Project: toward Molecular- and Reaction Discovery from Quantum Mechanical Global Reaction Route Mappings".

Pharo Git Thermite

A visual tool developed in Pharo for assessing Git commits and GitHub Pull Requests

The project is available on GitHub: https://github.com/ronsaldo/pharo-git-thermite

and now also integrates with Iceberg:
 


Read more details here.

JupyterTalk

JupyterTalk makes good progress - nice!

 Project is on GitHub: https://github.com/jmari/JupyterTalk

Exploring Pharo

There is a nice blog post about his initial experience with Pharo from Konrad Hinsen. He overall likes Pharo and especially the explorability but also has two primary points to criticize:

1. he mentions that Pharo is not reproducible and can not be bootstrapped from its own source code 
2. it is not easy for beginners to follow Pharo
   

The first point is actually invalid. Konrad seem to have missed that Pharo since two years IS ACTUALLY  BOOTSTRAPPED - so we can build a image from scratch and from our own source code. This is actualy in place and used to build Pharo now. Even smaller images (like the minimal one) beside what is provided in the default Pharo download.

People interested in this topic should read this blog post from 2014 and check the "bootstrap" folder in the Pharo github project. This is based on the PharoBootstrap work. Someone interested in this topic might also be interested in this video.

For the second point I agree as Pharo is moving fast it might not be easy to follow. Also the community is small. Due to this we can not invest our sparce resources into making things easy for newbees - but rather will continue to focus on moving forward. Especially with the upcoming Pharo 7 including better git support and the new Calypso browser many things have changed compared to Pharo 6.

But there are books available and there is the mailinglists as well as the Discord chat to ask questions and get answers. Situation is far better than in 1994 when I dived into Smalltalk and where it was not easy to get informations or even a free system to enjoy the openess and productivity of such a system.

Nonetheless - as one of the primary contributors of the Pharo project I really enjoy such blog posts. It shows we are on the right track. There is still a long way to go - but step by step it goes...

GeoSphere in Pharo

A project to compute distances, parse coordinates, etc. using Pharo.

See https://github.com/akgrant43/GeoSphere

How to use Extensions in Pharo

In Pharo it was always possible for a package to extend a class within another Package. So far it was done by putting a * in front of the method name.

In Pharo 7 this changes a little bit as you can directly select the extension from the new Calypso system browser.

Here is a description about the differences.

Mobile Apps Development with PharoJS

A new description on how to use PharoJS is available.

What FP can learn from Smalltalk

Dynamic creation of compiler plugins in Pharo

A new class (merged this week into Pharo 7) called "OCCompilerDynamicASTPlugin" allows for the dynamic creation of compiler plugins

Object compiler
 addPlugin: 
  (OCCompilerDynamicASTPlugin 
   newFromTransformBlock: [ :ast | (RBParseTreeRewriter replaceLiteral: 42 with: 'meaning of life') executeTree: ast. ast. ]
   andPriority: 0
  );
 evaluate: '42'.

This would give 'meaning of life'

Squeak 5.2. released

Squeak 5.2. is released

New Roassal Video

New video on Roassal. It is also available on http://agilevisualization.com

PTerm - Terminal Emulator for Pharo

PTerm: yet another Terminal Emulator for Pharo. The project is on GitHub.

PharoRoulette

Found a Roulette game build with Pharo / Seaside on GitHub. Need to try it out.

Reshaping the Development Experience

feenk wants to "Reshape the Development Experience" with a new GT Toolkit.

The project is online at https://feenk.com/gt/


The slides from ESUG 2018 are now also available:

 

3D Print your own Pharo Lighthouse

You have a 3D printer and would like to print out the Pharo logo lighthouse? Here is how - just visit this page for all the details.

Parser performance in Smalltalk

Some insights into Parser performance in Smalltalk

Pharo totally bootstraps

Rather unnoticed but is now finally working:

Pharo images are now build from NOTHING. Not a single byte of image exists before: During build process, a very small image is first bootstrapped using a technique developed by Guille Polito during his PhD. Then the rest of the packages are loaded in a regular way.

This is how Pharo 7 (which is intended to be released around November) is now built!

Truly object oriented test

How to find out if a system is truly object oriented. In this old video Dan Ingalls explains how you can simply test this.

In Smalltalk systems like Squeak and Pharo you can do it.

GotalkInterpreter

I like Go as a programming language. It is open source, has a funny mascot and supports easy creation of executables. Still it is not the same as working with a nice Smalltalk system like Pharo.

I guess others see it the same way. That's why a simplistic Smalltalk code interpreter written in Golang is available here: https://github.com/SealNTibbers/GotalkInterpreter

To quote: Why Smalltalk Smalltalk is beautiful dynamic language with a concise and readable syntax. Also we are smalltalkers so that's why.

Stylesheet for Pharo

When writing stylesheets (CSS) for the web it is not recommended to hard code the colors in each stylesheet rule - because often it is a tedious task to adopt or change them afterwards.

Therefore often people use CSS preprocessors like LESS or SaaS or Stylus where you can define variables or other to ease the job.

If you already work in Pharo you might want to easily write your stylesheets in Smalltalk. Thats the idea behind "Stylesheet" - a project to define CSS like stylesheet in Pharo applications.

The project was now migrated from SmalltalkHub to GitHub and can be found on: https://github.com/pharo-contributions/Stylesheet

Pharo Artefact migrated to GitHub

The Artefact PDF generation library written in Pharo was migrated to GitHub (including the STHub history):

https://github.com/pharo-contributions/Artefact

Here is an old video on it:

Pharo IoT Hackathon

There is an Pharo IoT Hackathon on 19th of October 2018 in Cologne by zweidenker Pharo company. Details are here.

 

Docker and Pharo @ZWEIDENKER

The Zweidenker company gave some insights on ESUG 2018 in their usage of Pharo and Docker:


 

MetaLinks Lecture from ESUG 2018

Pharo provides advanced reflection including MetaLinks. You can find more details on all the possibilities in my Pharo wiki collection.

The slides on this topic from ESUG 2018 are available online now:


 

Pharo and IoT - ESUG 2018 slides

Hacktivismo de datos en Smalltalk

The MadridSUG (Madrid Smalltalk user group) started a new event called "Hacktivismo de datos en Smalltalk". Details are here and here

Cormas in 10 years

Cormas is an agent-based modelling and simulation platform. The project can be found on https://github.com/cormas/cormas with a webpage on http://cormas.cirad.fr/indexeng.htm

The system is currently implemented in VisualWorks Smalltalk with a port started to Pharo Smalltalk.

There is a funny video of the CORMAS guys where they see Cormas in 10 years:

 

Gemstone support for Pharo

Gemstone is a very nice object oriented database. At ESUG 2018 there was native Support for Pharo (GemBuilder for Pharo) announced. Read the details in the slides.

Do you really understand git

Another presentation from ESUG 2018 about git:

Pharo in Corner Cases of the Enterprise

Slides from ESUG 2018 presentation on doing business projects using Pharo. The title is "Pharo in Corner Cases of the Enterprise"


 

Pharo and SendGrid v3 API

The SendGrid Smalltalk project is now gradually supporting the v3 API of SendGrid email delivery service. More on https://github.com/sorabito/sendgrid-smalltalk

Pharo Script of the Day

there is a new series of posts on a "Pharo script of the day" by Hernán Morales Durand. So far the following topics were covered:

• Proto proto image preprocessing in Pharo
• Poor's man test runner: Run package tests in Pharo from a script
• Open a line-numbered text editor
• Hash password with PBKDF2 using ApplicationSecurity
• Configure R <-> Pharo Smalltalk with RProjectConnector
• Migrate FileReferences from Linux/MacOS to Windows
• Prefix all class names in a package
• Replay cookies with Zinc HTTP components
• Sort a column in a CSV file
• Parsing Gene Ontology terms
• Rename instance variables programmatically

ESUG 2018 Conference Report

is available here.

ARCOS - Augmented Reality Collabroative Operating System

Several times within this blog I reported about Croquet. It was written in Squeak Smalltalk and supported communication, collaboration, resource sharing, and synchronous computation among multiple users. Basically it was a followup of ideas from Morphic - but all in 3D. You could create and visit portals to interactively collaborate.


 If I remember correctly it was later open sourced and ended up in OpenCobalt.NET - there are still some infos are on the Squeak wiki and a video on Youtube.



 It was also continued as OpenQwaq platform and used to form solutions for a company named 3dicc
(started by Ron Teitelbaum, David A Smith and Andreas Raab).

I also reported on the Lively Kernel project - a JavaScript based Kernel and IDE to also followup on these ideas allowing dynamic and linked worlds within your web browser. There is also a video available.

Now it seems there is a fully new web based implementation of these historic ideas available. It is called ARCOS - Augmented Reality Collabroative Operating System and if you check it out you will find many similarities.

Fully written in JavaScript and based on LivelyKernel but with a similar UI as in Squeak Croquet. If you check out the source code you will even find that the classes are prefixed with a "T" - which was back in the time the prefix for TeaTime (a specific framework for Croquet).

You can try it instantly in your browser using the following link or watch the following videos for a demo:

Caffeine.js and WebVR - Smalltalk in 3D

Craig is continuing on his caffeine Project - which uses SqueakJS for a binding to JavaScript. He plays with WebVR and it is nice to see Squeak Smalltalk running in the browser in 3D.

A demo is here:

https://caffeine.js.org/a-frame/

PharoJS V22 available

PharoJS V22 is available on SmalltalkHub.

From the release notes: RELEASE V22 Added statistics package. Generates statistics about Pharo classes used by an app and the size of generated JS code Fixed default app folder parent to fit the modification in github repo = non-pharo code moved to HTML folder

This is like the last version done on Pharo 5 and SmalltalkHub as Noury will switch to GitHub now.

Jun meets GTInspector

Combining Jun 3D with GTInspector:

 

Creating Bloc Widgets in Pharo

Creating Bloc Widgets in Pharo: - part 1 - part 2 - part 3

ESUG 2018 - Slides on Pharo evolution

Slides from ESUG 2018 from Esteban on Pharo evolution and current roadmap.

ESUG 2018 - Clap Slides

Slides from ESUG 2018 about Clap - the Pharo Command line Parser. Code is on https://github.com/cdlm/clap-st

ESUG 2018

is running. You can follow it using the various tweets.

Farmers Market App don in PharoJS

News from ESUG 2018 also on PharoJS:

The Farmers Market App at https://nootrix.com/farmers-market-app/ is built in PharoJS

Shampoo - Emacs Smalltalk development

Shampoo: a set of tools for remote Smalltalk development with Emacs.

• Project page is here: http://dmitrymatveev.co.uk/shampoo
• Source is available on GitHub: 
• https://github.com/dmatveev/shampoo
• https://github.com/dmatveev/shampoo-emacs
• https://github.com/dmatveev/shampoo-homepage

Basically it is constructed using a Smalltalk image-side server that provides a remote access to an image and a Shampoo mode for Emacs. It also runs for latest Pharo as this picture proves.

Geranium - agent-based simulator in Pharo

Geranium is an agent-based simulator with a dedicated DSL, for analyzing energy consumption in residential urban environments. The model takes into account structural, social and micro-climate characteristics. It is written using Pharo and here is a video session:




Code is on https://gitlab.com/npapoylias/Geranium and a project page can be found here.

You can also check the following PDF with a presentation including some more details.

ESUG 2018

Next week ESUG 2018 Smalltalk conference will start. You for sure will find infos and news on

https://twitter.com/hashtag/esug18
https://twitter.com/hashtag/esug2018

HoneyGinger in Pharo

I already reported on HoneyGinger in the past.

This is a new demo movie for HoneyGinger, a fluid dynamics engine written in pure Pharo.

NeoVIM client in Pharo

A NeoVIM client written in Pharo.

Roassal and Hololens

Roassal looks even cooler when presented using a Hololens...

HDFS for Pharo

A library to access the Hadoop Distributed File System (HDFS) from Pharo. Nice!

Pharo code completion work

Article from Myroslava on her internship at INRIA with infos on her work on code completion in Pharo

git-migration and Tonel for Pharo

If you want to migrate projects from SmalltalkHub (or any MCZ-based repo) to GitHub to profit from new git integration in Pharo then use Peters "git-migration" tool.

The tool is now using the Tonel format to store the code. Tonel is a file-per-class format, that means a class and all methods are stored in a single file. This is faster than having a file for each method but also prevents some trouble with git on Windows due to number of files and subdirectory depth.

Amber Smalltalk and npm

Amber Smalltalk and accompanying libs do not use bower any more, everything is based off Node package manager (npm) only now. Read more.

If you have an old command line interface (old amber-cli from previous installations) then uninstall it first.

GeoHash for Pharo

Pharo package to decode/encode Geohashes to/from latitude and longitude (geolocation).

Available on GitHub: https://github.com/simonfranz/smalltalk-geohash

Using Docker with Pharo

Two small tutorials on how to use Docker and Pharo: - Tutorial one - Tutorial two

Pharo Newsletter Summer 2018

is available here.

CuisSmalltalk Live templates

A prototype of LiveTemplates for Smalltalk - implemented in CuisSmalltalk. Shows how quickly and easily one can adopt a Smalltalk IDE.

RDF for Smalltalk

Christian Haider made his code available to deal with RDF/XML file. Check out his Resource Description Framework (RDF) page. It is currently for VW - but I guess porters are welcome.

Clap Teaser

Clap - is the Command line argument parser for Pharo. The project is available on GitHub now including a teaser to demonstrate some features.

A quick memory game using Pharo’s dynamic spec builder

Spec is a UI framework used in Pharo. It not only allows to declare static layout but you can also dynamically use it.

Here is a new medium article explaining some of it's features using a memory game as a demonstration. Nice!

Test-driven development for generated portable Javascript apps

some more infos on PharoJS

Improved Playground

Feenk is improving the Playground

A mini scheme in Pharo

Now as a PDF and HTML. Looks like more of the Pharo books are converted to be available in both formats.

Exemplifying software in Pharo

An article on working with example based programming using Pharo.

Controlling a Turtlebot using PhaROS: Goals planning and Automatic docking

Read more details here or watch the video: