the hidden parameter

STZ is multithreaded. Therefore globals that aren't const are very bad. We still need a way to conveniently pass around some 'global like' information though. Let's consider the most important one - memory management. There's a school of thought that says you

coroutines using tina

The idea that we can support different kinds of coroutines libraries in STZ makes me happy. So much so I think it's worth abandoning the Smalltalk-80 fork API and providing the libraries as-is, with some nice wrapping to clean them up. Tina provides us not only with asynchronous

coroutines using minicoro

Let's approach coroutines as something we utilise rather than get in the language. Using the minicoro library and the ability to use C code directly from STZ, let's see what it'll take to utilise. Starting with the basics - let's create a

another attempt

It will come as no surprise to people who know me that using <> as a grouping mechanism for any kind of information is distasteful. It visually conflicts with less than, greater than, etc. It's already visually conflicting with select> and do>. I made all

not ambiguous, just displeasing

(Integer | 1,) (my-object | b | c) (MyType | my-object | b | c,) The | is used in a lot of places to delineate between 'the type' and 'the code' inside of list creation (type | ...elements...), methods and blocks [type | ...code...], new object {type | ...code list...}. We have also been using

when to use a reference

There's two ways to pass objects as parameters in a method. Either as a copy or as a reference. If we're simply using the data, we pass it as a copy. If we intend to modify it we pass it as a reference. Copying large objects

write file to stdout

Just for fun let's try and write a low level program using mmap to read a file and write it to stdout. requires: 'libc'. [main: arguments] [filename := arguments[0] else| panic. // Open file or die fd := (libc open: filename flags: O_RDONLY) else| panic. --- [libc

break

[self my-method: arg] [:MyClass, :Integer -> ø | [ -> break | arg = 1 then: [self do-thing-one; break]; arg = 2 then: [self do-thing-two; break]; arg = 3 then: [self do-thing-three-fall-through]; arg ≤ 4 then: [self do-thing-four; break]; self do-thing-default; ] self do-other-stuff] This falls out of the current syntax nicely. You can even assign

another pass at blocks

I know I've painted this bike shed a few times but it dawned on me that it's iterated enough that we can swing back around to some Smalltalk syntax. The original idea was to use [ signature | types | code ] and [ types | code ] to reflect the Smalltalk-80 block

streaming without coroutines

Let's try again but this time we do things the simpler way. Brick and Mortar. That's the idea of low level programming anyway. Nothing fancy. We have a few combinations we care about: socket file array block socket X X X X file X X X

streaming with coroutines

It's worth considering just how the | operator works when it hits a terminal. There are three cases we want to consider 1) processing with a block, 2) writing in to another collection, and 3) writing to a socket. In the first scenario we want to read from the

node tree

Let's try and code something simple. A tree of nodes: Node (name: String, children: (Array of: Node)) We can likely use this right away to simulate HTML (without attributes): document: Node = {name: 'html', children: ( {name: 'head'}, {name: 'body'}) } Let's keep