[jl8] Index Page

[View] [Edit] [Lock] [References] [Attachments] [History] [Home] [Changes] [Search] [Help]

[jl8] Index Page

The jl8 platform

We are runing S8 Smalltalk systems on Julia execution runtimes.

Status: Open 1.0 release (Apr 2022)
Follow us on Facebook
License terms: the same as all S8 contents, MIT licensed

The platform files can be found in jl8 folder at U8
- Contain all source files needed to run S8 kernel on Julia and core test files.
- The tests for the platform can be run using console mode or connecting remotelly from U8 workbench:
  1. start the System Server in Julia console with
    start(smalltalk.SystemServer)
  2. press the connect icon in a workspace to evaluate smalltalk expressions remotelly in the jl8 system

Test program

Anyone can join us for testing and start moving your objects to run on space executed by Julia execution machinery
The suggested channel of communication is our Facebook Group and using email or FB messenger.

Executing jl8 platform

We have many alternatives to run jl8 systems, basically we need a Julia execution runtime to load a S8 snapshot file. We load the snapshot and the S8 system start running as usual.
The snapshot can be built in console mode (same as we do for most S8 platforms) to be embedded in the hosting execution environment.

Steps to start working on [jl8] platform (console mode):

ensure you have Julia execution machinery installed and running OK
- Read platforms installation page to ensure Julia is in your Path
download the jl8.zip file from U8 service
decompress the file in a new folder
execute the jl8.jl file to start a clean image
julia -i jl8.jl
evaluate julia commands using smalltalk global variable to access your objects
Sample expressions
- To get the version
  version(smalltalk.Smalltalk)
- licenseTerms(current(smalltalk.Smalltalk))
- sorted(selectors(smalltalk.Object))
- doIt("3+4")
Running Tests
- evaluate the (julia) expression
  t() # to run the dev. testset
- See file "build/testsXXX.txt" to read testset
- See also contents of folder "build/tests"
Running frameworks and S8 wrappers
- Some framework wrappers need the native implementation to be installed manually from Julia global repository. So you must run the installation steps in console.
- For example, to run tests (with t() command) you must have installed some packages
  The following commands can be evaluated in console to install the packages
- import Pkg; Pkg.add("JSON3")
  import Pkg; Pkg.add("HTTP")
- After installing a package, you can evaluate t() to run the tests again.
  The JSON3 and HTTP packages are required by SystemServer

If you want to run a snapshot file execute
julia -i s8.snapshot.jl

Where are we running jl8 ?

We have tested that the S8 system in the following execution environments, without changes:

OS, Runtime context	Julia version
MacOS Monterrey (12.3.1)	1.7.2; Feb 6,2022
Windows 10 64 bits	1.7.2; Feb 6,2022
Raspberry Pi Raspbian 8.0	-ToDo-

It has been tested running the default system image with:

Kernel
SystemServer and remote access from U8 workbench
native wrappers

The tests includes:

automated swiki testset for jl8
rebuild of the kernel and libraries (full recompilation of the system)
- Evaluate expression "Object recompileAll"

Well known bugs and issues

If you observed an issue or bug, please report it here or in our facebook group

What is included in jl8?

The complete S8 kernel. It is the SAME system that is running and used in all platforms where S8 smalltalk is running. The initial snapshot was produced Exporting the system using an instance of JuliaEncoder (browse Exporter and NativeEncoder hierarchy to learn more on how to jump to another native language). After decompression the jl8.zip file see under "build" folder the source files to produce an image from an existing S8 system (running on other platform & native language).

The "build" folder contains the s8 kernel used to produce the initial snapshot (after loading the first snapshot on a julia VM, you can save the image/snapshot as usual).
The "library" folder has additional S8 frameworks and wrappers to standard julia libraries
The "s8/library" folder contain frameworks extending jl8 to support remote U8 toolset.

Advanced features of jl8 platform

Julia runtime has an aggressive optimizing compiler that takes a LOOOT of time to compile functions the first tim eit runs to machine code.
The first time each method is activated it takes a long time to run; but after compilation, the method run faster that other platforms.
This makes jl8 platform valuable for servers working on huge amounts of data, science, IA, image and math processing (read more on where Julia is used to find domains of application of S8 systems running jl8).

Looong time wait can be observed in two situations:

Loading your snapshot/image/modules (julia loading)
On first time activation (julia compilation)

To avoid long loading times, you can produce a Julia Package to let Julia reduce loading times using an internal cache.

See folder "ServerApp" that implement a "precompiles.jl" list to reduce the loading time
The precompile.jl file can be obtained running u8_trace.jl script

Read ServerApp/src/ReadMe.txt file to learn more on how to produce snapshot and precompile list for a package containing a S8 Sytem

Another way to reduce loading time is building a Julia SysImage for your system.

Running S8 in reactive Pluto workspaces

A Pluto notebook is made up of small blocks of Julia code (cells) and together they form a reactive notebook.
When you change a variable, Pluto automatically re-runs the cells that refer to it.
Cells can even be placed in arbitrary order.
You can embedd a snapshot in a workspace of include the snapshot from external file(s).
If your system is defined as a Julia Package, it can be loaded in the page with "using".
See examples under the folder "Pluto" of the platform files.

ToDo list

If you want to collaborate on this platform, you can peek a topic and discuss or get guidance to implement it.
Suggested topics in our ToDo list

Test and complete impl. for S8 Sharing frw; to exchange objects from/to S8 systems running on top of js, lua and python

Other references

The Julia Programming Language Home, download and documentation