Pavel Krivanek has written a great article on the Self Object Model which is worth a read, or you can discuss it on news.ycombinator.com or reddit.

Newcomer Gregg has been doing a series of great short Youtube clips showing off the Self  GUI development environment. Check it out!

It’s been a while since we did a proper release of Self – too long in fact.

The last duck themed release was “Mallard” a couple of years (!) back – we’re overdue for more ducks so here is a new release of Self brought to you by this beauty:

Self 2017.1 is downloadable for Linux x86 (.zip) and MacOS (.dmg), or you can build it yourself from the GitHub source tree.

There is also a handbook included and available to read online.

A brief change log is:

New features:

• Changed to new versioning system for key subsystems (vm, core, morphic, outliners)   and for release as a whole.
• New `about` object accessible from main menu with system info.
• New `preferences` object allows easy access to system preferences.
• ew themeing system for outliners and a new look.
• Extensive reorganisation of object categories in `globals` to make global objects more easily discoverable and understandable.
• New option on `worldbuilder.self` script to allow for fully automated building of Self worlds by setting subsystem options on command line.
• New string helper methods: `splitOn:`, `joinUsing:` and `slice:`.
• The `transporter` is now aware of code being in multiple independent trees, not  only one single Self tree, allowing for separate projects to be kept in separate   version control repositories.
• A system-wide logger has been included to standardise logging practices within    Self.

Updates:

• Self Control.app on macOS updated to work with El Capitan.

Fixes:

• Fix on macOS to reduce CPU usage when idle.
• VM build will now explicitly show which macOS SDK it is using.
• ^D (EOF) handled correctly at prompt
• Fix to bug preventing compilation on recent GCC
• Many other misc fixes.

Documentation:

• General improvements to Self handbook.
• Self website moved out of main repository.

Other:

• Webserver moved to separate repository: github.com/russellallen/self-webserver
• travis-ci.org integration for VM building

It’s been a while since we did a Self release, and although there is a never ending stream of things which should be done and aren’t, I’m moving towards a new release so that our GitHub version isn’t too far out of sync with the last release version.

As part of that preparation process, I’ve fixed up some work Tobias started and have integrated with travis-ci.org.  Every push to the master branch on GitHub now builds and tests four VMs: Linux with GCC, Linux with Clang, macOS with GCC, macOS with Clang.

You’ll be pleased to know that our current status is:

I have long maintained that Self is the finest Yak shaving system in existence. Everything is possible and nothing is finished 🙂

So I was playing with building a website front end for the mailing list archives, which led me to improving the Self web server, which led me to making a new experimental stream framework for Self. This also led me to some interesting ideas on automatically checking for methods which should be present in an object but aren’t, but I’ll write about that later!

Self already has a readStream and writeStream prototypes, which are very basic entities modelled largely on Smalltalk-80. They’re mainly used in the context reading and writing to files and sockets.

What I’ve put together is a quick stream framework for putting together pipelines of filters etc and streaming objects through them. The general aim is to avoid the technical and conceptual overhead of copying collections multiple times as you handle them.

This isn’t particularly groundbreaking, lots of other languages do this sort of thing. I’d like to hear suggestions on how to make what I’ve done more elegant and Self-ish.

The code is at https://github.com/russellallen/flow

Basically, streams are entities which understand either readIfFail: or write:IfFail:. Streams can only be read or write.

Flow streams are composable, which means you can link them in a chain with pipeable connectors.

The relevant parts are in the global object ‘flow’.

This isn’t optimised at all – ideally streams should cheat by copying larger chunks behind the scenes where appropriate for performance. Also file streams probably need to be more aware of reading and writing chunks with internal buffers, and string writing should be optimised to reduce copying!

Possible improvements include adding spitting and merging pipes, specific buffering pipes etc.

Using flow streams is a two or three step process:

1 Build structure.

| myPipeline |

myPipeline: 
      'This is a bit of text for us to play with' reading 
   |= (flow pipeable map copyOn: [|:c| c capitalize])
   |= (flow pipeable filter copyOn: [|:c| c isVowel])
   |= (flow pipeable gather copyOn: [|:c| (c & c) asList])
   |= flow writable string copy. 

2 Put pipeline into action

myPipeline flush.

3 (Optionally) convert your stream into something else

[myPipeline contents = 'IIIIAAIIOOEEOOUUOOAAII'] assert.

And that’s about it. I’ll play with this some more, any suggestions?

tl;dr

Here: https://github.com/Bystroushaak/self_mbox/raw/master/self_full.mbox.lzma

Basic informations here: https://github.com/Bystroushaak/self_mbox Read the rest of this entry »

David Ungar and Harold Ossher’s talk at SPLASH 2013, called “Dancing with Symmetry to Harness the Power of Complexity: Subjective Programming in Context” is now online with slides and video at InfoQ.

David and Harold discuss a new programming language and environment they have been researching which allows to contextual, multidimensional dispatch of messages so that the behaviour of objects depends on the context of the method invocation. They also give a quick demonstration of a development environment they have build to explore these ideas in Self.

Check it out!

Named after the majestic, awe inspiring Anas platyrhynchos, the latest Self release 4.5.0 is now available for download.

What’s new since 4.4?

• Build system redone by Tobias Pape. Now based on cmake, with a single modern build process for both Linux and OS X. The VM can be built on both GCC and Clang on the latest vesions of both operating systems.
• New Self Control.app on OS X to manage your running worlds as a more robust and featured replacement for the older ‘Self Droplet’. Use of this app is optional and you can still access the Self VM through the command line.
• New look for standard world, with better fonts, colours and greater use of space.
• Various fixes to the standard world, including a new build script ‘worldBuilder.self’ replacing several ad hoc build scripts.
• Updated Self Handbook at handbook.selflanguage.org

Sources for the VM and for the basic Self world are available as always from the GitHub repository. Although Self, like Smalltalk80, can use an image (in Self called a snapshot of a world), this can be built from text sources.

Self Mallard is available for OS X and Linux. You can download binaries:

• For OSX, a disk image containing the Self Control.app and a prebuilt clean snapshot (“Clean.snap”). Copy the app to your Applications folder, run it and click the Choose snapshot… button.
• For Linux, a gripped tar file containing a prebuilt 32-bit binary and Clean.snap. Unpack, then run ./Self -s Clean.snap