Pharo Days 2015

Torsten Bergmann has announced Pharo Days 2015 to be held January 29 and 30, 2015 in Lille France. Here's part of his announcement:

Start the year in the right spirit by joining the Pharo community for the Pharo Days 2015 on Thursday January 29 and Friday January 30 at INRIA, Lille, France. Meet your online colleagues, programmers and hackers in real life and experience how much you can pick up in just two days. Learn about key technologies, talk to core developers and other users, pair program and contribute to Pharo. Have fun and enjoy yourself.

It sounds like fun.  Check it out.

 https://medium.com/@svenvc/pharo-days-2015-6336d6ee2a23

Essence# in InfoQ

There's a great interview in InfoQ with Alan Lovejoy - the author of Essence#.  Essence# is Alan's ANSI-compliant Smalltalk running on .NET.  Check it out.

Thanks to Peter William Lount for the pointer.

Instantiations releases VA Smalltalk 8.6.1

Instantiations has released VA Smalltalk version 8.6.1.  New features include real-time code analytics. enhanced refactoring support, SQLite3 support and zip/gz support plus enhancements to Linux and Seaside.  Check it out:

VA Smalltalk 8.6.1

Cincom releases VisualWorks 8.0 and ObjectStudio 8.6

Cincom has released VisualWorks 8.0 and ObjectStudio 8.6.  This new version has dramatic new changes to the user interface including Text2, a new source code editor and UISkinning.  The changes are very exciting.  Check it out at the links below.

VisualWorks
ObjectStudio

OpenGL ES from Smalltalk on Android

Well, here's my first rendering of an OpenGL scene from Smalltalk on the Android:

It's your standard plain colored triangle on a plain background - so shoot me.  But this image was generated by calling OpenGL primitives from my Smalltalk VM on an Android device, so it's pretty special.

I've talked about this Smalltalk before here.  Here's the current status.  I have all of the same bytecodes as VisualWorks implemented with the exception of the bytecode for thisContext. This allows me to use the VisualWorks compiler for free.

My source code is kept in a Store package in a separate namespace.  To run the code, I package all the classes and methods from that package into an image file in my own format - the Android image isn't compatible with a standard VW image.  This image is added as an asset in an Android project and sent along with a .so shared object library for the VM where it runs on the Android.

There's no Java code in the project at all.  I'm using a native activity in C and I've merged the Android event loop into the Smalltalk interpreter loop.  This allows me to handle events from the Android although I currently don't have code for that.

For debugging purposes, I can package a development image.  On startup, this image connects by a socket connection to a VW application which I wrote to provide low-level debugging and stepping instructions.

The system is still in its infancy.  There are still lots of things to develop like the garbage collector and most of the class library.  I have some basic operations but there's a lot of work needed to build up the library.  So far I don't have large integers although that's in the works.  I do support Float and Double and these classes are being used to help build the OpenGL image above.

I'll be demoing this system at Camp Smalltalk in Vancouver.  I'd be happy to answer questions about it.  It still needs a lot of work, but it's starting to produce real results.

Camp Smalltalk in Nanaimo

Everything's booked.  My wife and I are heading to Nanaimo BC on October 3, 2014 to attend Camp Smalltalk.  I'll be demonstrating the mobile Smalltalk I'm developing - it will be a work in progress.  I may also be involved in a "Intro to Smalltalk" presentation there.  I'm heading back to Ottawa on October 6th.

If you're interested in attending, you can check out this link:

VanIsle CampSmalltalk

SimTalk - Smalltalk for Mobile Devices

Ok, the secret is out. I'm busy developing a Smalltalk for Android and (later) iOS devices.  It's a new implementation of Smalltalk from the ground up. Here's what I have and what I'm planning.

I'm currently developing a pure interpreter.  Later I may consider either dynamic compilation or compilation direct to native instructions.  For now, however, the easiest way to start is with a pure bytecode interpreter.  I'm using the same bytecode set as VisualWorks.  This is mostly for convenience. It means that I can use the VisualWorks compiler to create the bytecodes for the new Smalltalk.

I don't yet have garbage collection but I have everything setup to allow me to implement garbage collection. I'll have generation scavenging for new and survivor spaces and mark and sweep for old space.

I'm developing the system using three different languages.  Java is used as a shell (for now) to start the system.  I'll also be using it to perform various primitive operations.  The core of the interpreter itself is written in C under the Android NDK.  It can call back to Java using JNI when needed.  It's the C code that loads the image from an asset and runs the Smalltalk bytecodes.

So far, I can do simple arithmetic, pushing and popping of the stack, message sends and super calls.  Any looping or branching that compiles to bytecodes also works.  I was able to write a non-recursive factorial method that worked well.

The image for the new Smalltalk is generated by VisualWorks and sent to the Android as an asset in the APK file.  When Smalltalk launches, it loads the image then sets up a socket listener and waits for a connection.  At that point, a bytecode debugger I wrote in VisualWorks connects to the image.  This debugger can provide information about the memory spaces, dump the stack, inspect objects (in a fashion), and single step through the bytecodes.

Here's what the debugger looks like so far:

This is a stack trace in the process of evaluating 3 + 4.  It's pushed the 3 and 4 onto the stack and is about to run the + method.  Remember, this is a temporary debugger for me to use at a very low level to make sure all the infrastructure is working.  Ultimately, I intend to tap into the VisualWorks debugger and direct its operations to run on the Android device.

Even though I have 95% of the VisualWorks bytecodes implemented, I'm still far away from getting the system as functional as I would like.  I need to properly implement blocks, add a lot of primitives, and develop a base class library for the new Smalltalk.  It's a lot of work but very exciting.

My current intention is to use this new Smalltalk to develop my own apps for commercial sale.  If, however, other people are interested in developing mobile apps in Smalltalk I can look into ways of licensing the application for others to use.  If this work interests you, drop me a line or leave me a comment.  I'd love to hear your thoughts.  You can also listen to the Independent Misinterpretations podcast episode 164 where I discuss the project with James.