Self-interest

self-interest@lists.selflanguage.org

2 participants
1919 discussions

Code mapping to a simple Java program
by 黃耀賢 (Yau-Hsien Huang) 12 May '24

12 May '24

Hi all. I did a work-around, mapping a simple Java program to a Self version. The Java one, ``` class Program { public static void main(String[] args) { int x = 5; System.out.println((x++ + ++x)); } } ``` Mapping: (x++) is mapped to `x ff`, while (++ x) to `++ nil`. The Self one, ``` (| ret. x = (| ff = ( ret: self v. self v: 1+ self v. self ). ret. v <- 5 |). ++ = (| :a | self x v: 1 + self x v. self ret: self x v. self ). main = (| a. b. nil. "This trick ..." "I do not known why `nil` not found in this method." | self x ff. a: self x ret. b: (self ++ nil) ret. self ret: a + b. (self ret) printLine. self ). |) main "will print 12" ``` -- Best Regards. --- Y-H. H.

2 2

UKSTUG meeting - Tudor Gîrba: What exactly is Glamorous Toolkit? - 24 April 2024
by UK Smalltalk 22 Apr '24

22 Apr '24

To some people Glamorous Toolkit is a Pharo environment. To others it’s a knowledge management system. Others might see a code analysis platform, a data visualization or an API browsing tool. Yet others see the graphical stack with its interactive editors. Glamorous Toolkit is all of these. But it’s really also none of these. These are merely examples of the many forms the environment can be molded to. And there can be many more. Glamorous Toolkit is primarily an environment that makes it possible to create many experiences seamlessly and contextually. This then leads to a new way of programming that we call Moldable Development. Tudor Gîrba is a software environmentalist and the CEO of feenk.com ( http://feenk.com/ ) where he works with an amazing team to make the inside of systems explainable. Much of the work is embodied in Glamorous Toolkit ( gtoolkit.com), a novel environment that enables moldable development. This will be an online meeting from home. If you'd like to join us, please sign up in advance on the meeting's Meetup page ( https://www.meetup.com/ukstug/events/300575234/ ) to receive the meeting details. Don’t forget to bring your laptop and drinks!

1 0

Self Update and Question
by Russell Allen 20 Apr '24

20 Apr '24

Hi all! I thought I'd give a general update... On the `dev` branch. we have a version of Self which will build and run (if the appropriate 32-bit libs are present) on the latest releases of Linux, FreeBSD and NetBSD. (With many thanks to https://github.com/nbuwe) Sadly we can’t build or run on MacOS anymore. We should run on WIndows under WSL2, but I haven't tried it. Linux works for most distros, however some like Ubuntu are increasingly painful for running 32-bit apps. Also I haven’t tried Self on a distro which uses Wayland instead of X11. There is a framework for building VMs at https://github.com/russellallen/Self-VM-Builder. It uses Qemu to provide emulations of various OS/architecture combinations. On the Self side, there is a bunch of small additions and changes to the main sources. We are very overdue to do a release. What I’m not sure of is what that looks like. I can see three options: (1) The easiest path is to just provide the source and let interested people build their own VMs. This is the approach take by, for example, SerenityOS. (2) If we want to provide binaries, we could try to get the VM into the main package repositories but there are a *lot* of them now, especially now we also have snap, flatpak etc! (3) Alternatively we could do what Rust and Pharo do, and provide a script to install, eg `curl https://install.selflanguage.org | sh` (But I know some people hate this) Does anyone have thoughts? Russell

1 0

Classless?
by xd3a9gsmwk＠liamekaens.com 07 Apr '24

07 Apr '24

Let's say we want to program a controller for four lift shafts to serve ten floors. We are going to have to model the idea of a call button, and model about 80 individual objects that conform to that idea, right? These would be involved in mediating the calculation that feeds the outputs toward the motor controllers, so as to drive the lift cars in the appropriate direction and speed to serve the calls, open the doors, etc. That's what a straightforward design would do in building such a controller, regardless of what programming language you were using, right? What would the code look like, where we model the call-button concept and the individual call buttons?

6 10

Examples?
by xd3a9gsmwk＠liamekaens.com 05 Apr '24

05 Apr '24

Is there a software library, written in Self and packaged as a module, that I can read?

2 1

A Case Where Cloning Seems Necessary
by xd3a9gsmwk＠liamekaens.com 04 Apr '24

04 Apr '24

I have been exercising a library that supports the creation of (speaking loosely) processes. When a process is launched from outside of any process of the scheme, the new process is told a procedure to execute. A process may `fork`, which creates and launches another process having some of the same attributes as the calling process (in particular, the same scheduler). Processes can terminate with success or failure. An operation `alts` is available that is handed a series of procedures to try until one of them succeeds. For implementing `fork`, `alts`, and similar operations, it seemed natural to want to clone the process. To support these uses, I packaged a scheme that allows to specify how cloning is to work for a clone family. The specification is handed to a library function and it returns the first prototype of the family. Client code will ask this prototype to clone itself to get objects to use (and mutate). The specification for a clone family can include: - methodsToBind: every clone will bear these as partially evaluated with itself as the receiver. The bound procedures are convenient to pass as callback functions, e. g. through the scheduler. - heritableProperties: these form the traits object to which all the clones delegate. - noCopyKeys: slots having these keys are not copied.

1 0

Newb question: pattern to generate objects with common behavior
by xd3a9gsmwk＠liamekaens.com 04 Apr '24

04 Apr '24

I tried reading much of the Handbook to answer this very basic question, and didn't find it. How do Self programmers usually set up to be able to create at runtime a family of objects with shared behavior, more or less analogously to using a class and its `new` selector or operator in some other languages? I understand, I think, the basic semantics provided by the Self object system. But what are the usual programmer practices as to paths to get to the relevant parts for the equivalent of a class? I suppose you might have a prototype object and a traits object, and your equivalent of `new` would be to ask the prototype object to clone itself, which gives you a shallow copy, right?

2 2

Making Objects From Patterns
by xd3a9gsmwk＠liamekaens.com 31 Mar '24

31 Mar '24

I am working in another language, but I want to learn from the viewpoint of Self enthusiasts. On Reddit, I said: In object-oriented programming, for most engineering benefit, is it better for client code to have to distinguish between cloning a prototype and instantiating a class? Or should I be able to pass to the client code an object that could be either a prototype or a class, so the client code could request a same-named operation in either event, and the result would be a clone or an instance? And if so, should the operation be called "clone", "new", "create", "make", or something else?

1 0

UKSTUG Meeting - Maximiliano Tabacman: Electronic Roleplaying Assistant - 27 March 2024
by Giovanni Corriga 19 Mar '24

19 Mar '24

In this presentation, Maximiliano Tabacman will be presenting the main features, abstractions and design decisions behind ERA, the Electronic Roleplaying Assistant ( https://preview.drivethrurpg.com/en/product/137825/ERA-for-Rolemaster ). ERA is currently being used to create characters and manage the adventures of many gaming groups across the world, supporting Navigator RPG, Against the Darkmaster, Rolemaster Classic, Rolemaster Fantasy and Rolemaster Unified. We will review how Pharo allows creating a deployed version that runs locally in Linux, Mac and Windows, while Digital Ocean and Auth0 allow running an online server with different user roles. https://pharo.org/success/RolPlayingAssistant.html We will also mention how ERA makes use of the different frameworks developed and maintained by the Buenos Aires Smalltalk group, hosted at Github. Maximiliano Tabacman ( https://www.linkedin.com/in/maximiliano-tabacman-9aa4b817b/ ) is a long time Smalltalker with a Phd from the University of Buenos Aires. He is a Software architect at Mercap, executive secretary at FAST and creator of ERA. This will be an online meeting from home. If you'd like to join us, please sign up in advance on the meeting's Meetup page ( https://www.meetup.com/ukstug/events/299364517/ ) to receive the meeting details. Don’t forget to bring your laptop and drinks!

1 0

UKSTUG Meeting 28 February 2024: Juan Vuletich - Bootstrap & Dynamic Cuis Libraries
by Giovanni Corriga 23 Feb '24

23 Feb '24

Juan Vuletich returns to the UKSTUG to discuss some recent enhancements to Cuis Smalltalk ( https://cuis.st/ ) : Bootstrap and Dynamic Cuis Libraries. Bootstrap: Creating Minimal Images from Scratch > * The last ancestor of Cuis Smalltalk that was bootstrapped from scratch was Smalltalk-76. Since then, various released images of Smalltalk-80, Squeak and Cuis were derived by applying updates to the previous one. A new tool called 'Bootstrap' allows the creation of minimal Smalltalk images from scratch. These images are in the Spur 32 and 64-bit formats, compatible with the OpenSmalltalk VM. 'Bootstrap' gives developers complete control over what is included in the new image. It is compact, relatively simple, and easy to extend and adapt. Dynamic Cuis Libraries: A binary format for Cuis code that is powerful and quick to load > * Dynamic Cuis Libraries are binary files with pre-compiled code that can be loaded into a running Cuis image. They can add new classes and extend existing ones. For existing classes, there are no requirements on the shape of that class in the image loading the library. Missing variables are added, extra variables are kept, and both existing and newly loaded methods are adjusted to whatever shape the class has. Juan Vuletich ( https://independent.academia.edu/JuanVuletich ) is the founder and lead developer of Cuis Smalltalk. He is a long-standing Open Source Smalltalk community member, having contributed kernel code to Cuis, Squeak and the Squeak VM for over 25 years. Juan has been programming since he was 14, and doing it professionally since he was 17. He holds an MS.Sc. in Computer Science from the University of Buenos Aires. He works at LabWare. This will be an online meeting from home. If you'd like to join us, please sign up in advance on the meeting's Meetup page ( https://www.meetup.com/ukstug/events/299084123/ ) to receive the meeting details. Don’t forget to bring your laptop and drinks!

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

1997

1996

1995

1994

1993

1992

1991

1990

Self-interest