#-*- org -*-
#+TITLE: Guile Goblins NEWS – history of user-visible changes
#+startup: show2levels

* Releases
** v0.18.0
*** Highlights
**** Sleepy actors
Sleepy actors are a new, optional caching layer has been added to the
core of Goblins.  Actors may now go to sleep or be woken up depending
on a customizable caching algorithm known as a "sleep strategy".  When
an actor goes to sleep, it is saved to the vat's persistence store but
its reference remains live.  When an asleep actor receives a message,
its state is restored from the vat's persistence store and the message
is processed as usual.  This release adds the core caching machinery,
but useful sleep strategies are not yet provided out of the box.
Future releases will implement practical strategies such as a "least
recently used" algorithm.

*** Miscellaneous changes
- Added support for merging into non-transactormap parents in
  =transactormap-buffer-merge=.
- Removed =op:deliver-only= OCapN operation that has been removed in
  current draft specification.
- Updated OCapN GC operations to match current draft specification.
- A special exception is now raised when an actor uses the wrong
  =bcom= capability to change its behavior.
- A special exception is now raised when =bcom= is used in an =on=
  handler.
- Exported =transactormap?= predicate in =(goblins core)=.
- Switched =^seteq= actor to use persistent hashmaps instead of
  vhashes.
- Rewrote explanation of Unix domain socket netlayer in manual.
- Improved build and installation of optional Hoot support.
- Source modules are now symlinked to =$prefix/share/guile-hoot/site=
  for use with Hoot.
- Improved performance of near/far refr checks in
  =actormap-read-object-portrait=.

*** Bug fixes
- Fixed a race condition where, during restoration with persisted
  data, an actor in vat A that is depended on by an actor vat B but no
  other actors in vat A could be garbage collected before vat B is
  restored.
- Fixed signing oracle vulnerability in WebSocket netlayer.
- Fixed several peristence regressions introduced in 0.17.0.
- Fixed persistence layer not handling nested tagged data.
- Fixed errors in migration example in manual.
- Fixed =with-vat= to throw a syntax error if used with fewer than two
  expressions.
- Fixed =op:gc-answer= test in OCapN test suite.
- Fixed Syrup serializtion of "pseudo-singles".

*** Known issues
**** Actors using define-actor along with its #:self keyword cannot persist
Issue: [[https://codeberg.org/spritely/goblins/issues/256][#256]]

Objects that are defined with =define-actor= and use the =#:self=
keyword should be persisted properly, but this currently is not the
case.  Instead, an error occurs.

**** Prelay connections are unencrypted and unauthenticated
Issue: [[https://codeberg.org/spritely/goblins/issues/144][#144]]

Messages sent through the Prelay netlayer can be viewed by the relay
server, modified and new messages inserted by the server or silently
removed and thus not delivered by the Prelay netlayer.

This means that, for the time being, you should only use the Prelay
netlayers where you can place high trust in the relaying server.  An
end-to-end encrypted relay is planned for a future release.

**** Lack of dialback within CapTP
Issue: [[https://codeberg.org/spritely/goblins/issues/50][#50]]

When a node connects to another node in Goblins it provides the
location from where it's accessible (i.e. the OCapN node address). One
feature of OCapN is to ensure only one connection exists to any given
node, since the address provided by a new incoming connection is never
authenticated, this could lead to a denial of service by a malicious
actor claiming to be a node it is not.

**** Heisenbug within =guix build= on aarch64
Issue: [[https://codeberg.org/spritely/goblins/issues/949][#949]]

For whatever reason, the test for enlivening and calling remote-refrs
over the unix domain socket netlayer fails on aarch64, but only when
run inside the =guix build= jail! So this test has been marked as an
expected failure for now.

** v0.17.0
*** Highlights
**** Bloblin store
This is a new persistence store which provides a fast and efficient Syrup based
store. Goblins vats are usually efficient providing only the deltas (i.e. the
portraits of changed objects), rather than the full graph. This store is able to
be fast by streaming these deltas to the file. This is much faster than writing
out the full graph each time an object changes (or rather for each churn).

This Bloblin store together with other changes in this release make for dramatic
improvements in persistence performance.
**** =^vector= and =^ring-buffer= actors in actor-lib
There are two new actors added to our standard library of actors provided with
Goblins. These are the =^vector= actor which wraps Scheme vector
implementation and =^ring-buffer= providing a
[[https://en.wikipedia.org/wiki/Circular_buffer][ring buffer]] (sometimes call a
circular buffer) implementation.

**** Persistence performance improvements and bug fixes
Performance has improved for taking object portraits (the most time critical
part of the persistence system). There were a number of actormap procedures
which were used when taking a portrait of every changed object, these called
=procedure-name= which is very expensive. This fix along with Bloblin should
make persistence much faster.

While not the bug fix section of the NEWS file, there are two persistence
related bugs which are large enough to deserve being called out here in the
highlights. The first bug occurred when performing actor upgrades through the
persistence system. If an actor changed via an upgrade, but didn't later call
=bcom= when running, the actors upgrade and any changes there after were not
persisted. This issue is now fixed. If an actor changes its version, the actor
is persisted after restoration.

The second persistence bug this release fixes concerns orphaned objects (i.e.
objects which no longer appear in the persistence graph). These objects are no
longer spawned upon restoration. This both used to waste resources by spawning
them even though they were not used, but also could cause side effects by
messaging other actors. The restoration now walks the graph of objects from the
roots, restoring only the objects which actually appear in the graph.
*** Bug fixes & Smaller features
- =define-actor= has had several bugs fixed, these are:
  - It now supports #:rest and #:allow-other-keys.
  - Invalid keywords now throw a syntax error.
  - Support for procedure properties and docstrings.
- Documented the OCapN procedures =spawn-mycapn=, =ocapn-id->string= and
  =string->ocapn-id=.
- Documented REPL all our metacommands.
- Install =(goblins persistence-store local-storage)=.
- Improved formatting of error messages.
- Added =,vat-log-resize= REPL command.
- Added procedure to convert between two persistence stores.
- Persistence speedups when taking portrait.
- Actors which upgrade have their changes persisted immediately.
- Only restore actors which appear in the graph (not orphaned objects).
- =^inbox= actor's self portrait procedure was fixed.
- Several spelling corrections in error messages and docs.
- Restored far refrs always persist correctly (previously would sometimes
  become broken promises).
- Fix the persistence environment for the simple mint and =^queue= actors
  (previously had incorrect restoration procedures).
*** Known issues
**** Actors using define-actor along with its #:self keyword cannot persist
Issue: [[https://codeberg.org/spritely/goblins/issues/256][#256]]

Objects that are defined with =define-actor= and use the =#:self=
keyword should be persisted properly, but this currently is not the
case.  Instead, an error occurs.

**** Prelay connections are unencrypted and unauthenticated
Issue: [[https://codeberg.org/spritely/goblins/issues/144][#144]]

Messages sent through the Prelay netlayer can be viewed by the relay
server, modified and new messages inserted by the server or silently
removed and thus not delivered by the Prelay netlayer.

This means that, for the time being, you should only use the Prelay
netlayers where you can place high trust in the relaying server.  An
end-to-end encrypted relay is planned for a future release.

**** Lack of dialback within CapTP
Issue: [[https://codeberg.org/spritely/goblins/issues/50][#50]]

When a node connects to another node in Goblins it provides the
location from where it's accessible (i.e. the OCapN node address). One
feature of OCapN is to ensure only one connection exists to any given
node, since the address provided by a new incoming connection is never
authenticated, this could lead to a denial of service by a malicious
actor claiming to be a node it is not.
** v0.16.1
*** Bug fixes
**** Fixed bug where netlayers could not be used with Hoot

This fixes a regression introduced in v0.16.0. This caused programs to have an
error when being compiled with Hoot if they used a netlayer. This in effect
prevented the use of OCapN in Hoot programs. This is now fixed.

The bug was caused by an issue in the ^io code using an unsupported procedure in
Hoot.
**** Fixed a bug where multiple sessions between two OCapN peers could exist

It's an important property of OCapN that only one session can exist between two
peers. OCapN has machinery to ensure this but due to a bug with how we were
treating OCapN Locators (i.e. `(goblins ocapn ids)`), multiple sessions could
be established if only the hints differed.

For Hoot programs, multiple sessions could be established even when the hints do
not differ and the OCapN Locator is the same. This was caused by
[a bug](https://codeberg.org/spritely/goblins/issues/806) around how Hoot hashes
values.

Both these issues have been fixed.
** v0.16.0
*** Highlights
**** Unix Domain Socket Netlayer

Another new netlayer has come to Goblins, this time one based on Unix domain
sockets. Unix domain sockets are ideal for communication between multiple
processes running on the same machine. Many users might be familiar with using
them where by sockets address using file paths on the system, however since the
file system on Unix(-like) systems use ACLs, this can lead to security
vulnerabilities.

Our implementation uses a feature of Unix domain sockets which allow sockets to
be sent and received over other sockets. We built an introduction server which
you run on your system (think of it as a little
[OCaps](https://en.wikipedia.org/wiki/Object-capability_model] kernel in amongst
the modern ACL sea that our systems are built on today). The Unix domain socket
netlayer can connect to one or multiple of these introduction servers and so
long as two netlayers share the same introduction server, they can securely
communicate with one another.

**** Performance speedups

Several areas of Goblins have received huge performance improvements, the two
main areas are simple sealers and spawning actors.

The simple sealers system in Goblins. Sealers provide a capability to "seal" a
value which makes it opaque until the value is "unsealed" with the unseal
capability. These sealers are used throughout core of Goblins, including "bcom"
and within promises. These sealer improvements alone should be expected to bring
around x20 better performance for spawning named actors (i.e. those spawned with
=spawn-named=) and x10 improvements for sending messages with promises.

The =spawn= procedure that's provided by =(goblins)= has got a speedup. Most
actors used have a debug name that is printed when a traceback involving the
actor is displayed or the actor reference is printed at the REPL. Prior to 0.16,
spawn would call =procedure-name= on the actor's constructor which is expensive.
We now have a macro which provides a fast path where possible which under the
hood calls the much faster =spawn-named=. This showed 22 times better
performance spawning actors in our testing.

*** Deprecations
The following should not be used in new projects and existing codebases should
move away from using them as they will be removed in future releases:

- =ocapn-node= has been renamed to =ocapn-peer=. This brings us into alignment
  with the naming decided by the [OCapN pre-standardization
  Group](https://ocapn.org). All accesses to the =ocapn-node= record have also
  been renamed.

*** Bug fixes
- =(goblins actor-lib methods)='s =extend-methods= macro no longer assumes the
  actor being extended is within the same vat. It now supports extending from
  actors from other vats or even over CapTP.
- If multiple far-refrs were being restored by persistence system, all but one
  of them would fail to restore properly. This has now been fixed.
- Promises settled to local far-refrs (i.e. refrs to actors on another vat but
  not over CapTP) would cause issues when the persistence system tried to
  serialize them. This is now fixed.
- CapTP did not set the correct session information in the
  =desc:handoff-receive= certificate when performing 3rd party handoffs. We now
  populate the correct session information and also check this information.
- When using the =(goblins persistence-store syrup)= store, sometimes if the
  goblins process was stopped during updating the file, the data would become
  corrupt. This fixes that by writing to temporary file and then atomically
  replacing the real store file preventing this corruption.
- Previously messages sent during restoration which resulted in an error
  would break restoration. This is now fixed to handle these errors properly.
- When sending messages to a promise chained with a promise for messages sent
  over CapTP did not result in promise pipelining behavior expected. This is now
  fixed to properly handle the promises chaining situation.
- =(goblins actor-lib pubsub)= had the wrong actor specified within the
  persistence environment, which would cause problems when used with the
  persistence system, this has now been fixed.
- The issue where persistent vats could not be used under Hoot has now been
  fixed.
- =define-actor= had a bug when using #:key/#:optional along with #:self. This
  has now been resolved. Notably this does not fix the issue around selfish
  actors not being persistable.
*** Known issues
**** Persisted objects are not cleaned up when orphaned
Issue: [[https://codeberg.org/spritely/goblins/issues/227][#227]]

When using Goblins' persistence system, the objects within a graph are
stored within the persistence store used.  When an object stops
appearing in the graph of objects, it's expected that the object would
be cleaned up and removed.  Goblins currently will continue to store
the object data and upon restoration the object will be respawned.
**** Actors using define-actor along with its #:self keyword cannot persist

Issue: [[https://codeberg.org/spritely/goblins/issues/256][#256]]

Objects that are defined with =define-actor= and use the =#:self=
keyword should be persisted properly, but this currently is not the
case.  Instead, an error occurs.
**** Prelay connections are unencrypted and unauthenticated

Issue: [[https://codeberg.org/spritely/goblins/issues/144][#144]]

Messages sent through the Prelay netlayer can be viewed by the relay
server, modified and new messages inserted by the server or silently
removed and thus not delivered by the Prelay netlayer.

This means that, for the time being, you should only use the Prelay
netlayers where you can place high trust in the relaying server.  An
end-to-end encrypted relay is planned for a future release.
**** Lack of dialback within CapTP

Issue: [[https://codeberg.org/spritely/goblins/issues/50][#50]]

When a node connects to another node in Goblins it provides the
location from where it's accessible (i.e. the OCapN node address). One
feature of OCapN is to ensure only one connection exists to any given
node, since the address provided by a new incoming connection is never
authenticated, this could lead to a denial of service by a malicious
actor claiming to be a node it is not.
** v0.15.1
*** New features and improvements
**** Added additional explanation of cooperative multitasking to manual

This includes explaining what an event loop is and common vat
pitfalls.  Added in response to user feedback and experience reports.

**** Added example of passing an actor reference over OCapN to manual

This was missing in our existing OCapN example, which created some
confusion around how to pass actor references between machines.

**** Added =race*= variant of =race= joiner

New =race*= procedure in the =(goblins actor-lib joiners)= module to
complement the existing =all-of*=.

**** Vectors and pairs are now serializable over CapTP.

Proper lists (a series of pairs terminated by the empty list) were
already serializable, but non-list usage of pairs (such as key/value
pairs within association lists) and vectors were not
supported... until now!

**** Exported =^persistence-registry= from =(goblins)= module

This just makes it more convenient to access this constructor without
importing additional modules.

**** The fake netlayer can now be halted

This is useful for automated testing.

**** Added =on-sever= support to the prelay netlayer

This meta-netlayer now propagates connection severance in the
netlayers it manages.

**** Added new =timeout= procedure

The =timeout= procedure is for creating promises that resolve after a
certain amount of time has passed.  =timeout= can be found in the new
=(goblins actor-lib timers)= module.

**** Suppressed "overrides core binding" warning when importing =(goblins)=

Guile's default environment has a =spawn= procedure, a POSIX wrapper.
Importing =(goblins)= replaces that with its own =spawn= for
instantiating actors.  This caused lots of noise in the form of
warnings.  This warning has now been silenced.

*** Bug fixes

**** Fixed sending ghashes over CapTP

Ghashes that keys/values containing complex objects, such as actor
references, were not being serialized properly.

**** Fixed sending messages to far references in persistent vats

Issue: [[https://codeberg.org/spritely/goblins/issues/272][#272]]

**** Fixed thread-safety issues in CapTP garbage collection

Issue: [[https://codeberg.org/spritely/goblins/issues/243][#243]]

**** Fixed issue where severed connections to peers couldn’t be re-enlivened

Issue: [[https://codeberg.org/spritely/goblins/issues/657][#657]]

**** Fixed CapTP crossed hellos mitigation

**** Fixed =call-with-vat= blocking the current vat’s event loop

Issue: [[https://codeberg.org/spritely/goblins/issues/664][#664]]

It now returns a promise when called in this context.

**** Fixed prelay netlayer not reconnecting after severance

Issue: [[https://codeberg.org/spritely/goblins/issues/281][#281]]

**** Fixed prelay severance breaking local references

Issue: [[https://codeberg.org/spritely/goblins/issues/657][#657]]

**** Fixed =on-sever= for WebSocket netlayer on Hoot

**** Fixed WebSocket error handling on Hoot

Issue: [[https://codeberg.org/spritely/goblins/issues/680][#680]]

**** Fixed =(goblins ocapn netlayer base-port)= not compiling with Hoot

Issue: [[https://codeberg.org/spritely/goblins/issues/665][#665]]

This includes fixing issues lower in the module dependency graph.

**** Fixed installing testing utility libraries

Issue: [[https://codeberg.org/spritely/goblins/issues/282][#282]]

=make install= will no longer install modules that are only for the
test suite.

** v0.15
*** Highlights
**** Goblins on the web

Goblins has come to the browser!  You can now use Goblins in your
Guile project and compile it to WebAssembly using Hoot.  All of the
goodies you're used to such as vats, OCapN and almost all of actor-lib
(=selfish-spawn=, which is now deprecated, does not work) can be used
when compiling with Hoot.  The Webassembly binaries produced by Hoot
can be used in Firefox, Chromium, and Webkit based browsers.  Hoot
also includes a JavaScript FFI, meaning you can access additional
browser APIs as needed.

**** WebSocket netlayer

The WebSocket netlayer is as the name suggests, a netlayer which works
by communicating via [[https://datatracker.ietf.org/doc/html/rfc6455][WebSockets]].  WebSocket are, of course, available
on the web but also in the Guile VM via guile-websocket.  This is the
first netlayer which can be used in both Hoot and Guile.  It's
important to note that that due to limitations within web browser
environments, this netlayer works only as a client (outbound
connections only) on Hoot and requires secure WebSocket servers with
valid TLS certificates in most situations.  Thus this netlayer should
be considered a "bootstrap" netlayer that is used to connect to an
instance of the Prelay netlayer and reach a peer-to-peer Goblins
network.

**** Performance improvements

This release of Goblins has a major speedup: 1.2-2x performance
improvements for all Goblins-using code!  Now your Goblins programs
run faster than ever!

Even more performance improvements are planned for upcoming releases,
this is just the beginning!

*** Deprecations

The following should not be used in new projects and existing
codebases should move away from using them as they will be removed in
future releases:

- =(goblins actor-lib selfish-spawn)= is deprecated in favour of using
  the =#:self= keyword in =define-actor=.
- =(spawn-promise-values)= has been replaced with
  =(spawn-promise-and-resolver)=
- =(spawn-promise-cons)= has been deprecated.  It's advised to use
  =(spawn-promise-and-resolver)= instead.  However, if a single value
  within a cons cell is required, you can replace it with
  =(call-with-values spawn-promise-and-resolver cons)=.

*** Bug Fixes
- Persistable object identifiers are now persistable using Goblins'
  persistence system.

*** Known issues
**** Persisted objects are not cleaned up when orphaned

Issue: [[https://codeberg.org/spritely/goblins/issues/227][#227]]

When using Goblins' persistence system, the objects within a graph are
stored within the persistence store used.  When an object stops
appearing in the graph of objects, it's expected that the object would
be cleaned up and removed.  Goblins currently will continue to store
the object data and upon restoration the object will be respawned.

**** Actors using define-actor along with its #:self keyword cannot persist

Issue: [[https://codeberg.org/spritely/goblins/issues/256][#256]]

Objects that are defined with =define-actor= and use the =#:self=
keyword should be persisted properly, but this currently is not the
case.  Instead, an error occurs.

**** Prelay connections are unencrypted and unauthenticated

Issue: [[https://codeberg.org/spritely/goblins/issues/144][#144]]

Messages sent through the Prelay netlayer can be viewed by the relay
server, modified and new messages inserted by the server or silently
removed and thus not delivered by the Prelay netlayer.

This means that, for the time being, you should only use the Prelay
netlayers where you can place high trust in the relaying server.  An
end-to-end encrypted relay is planned for a future release.

**** Lack of dialback within CapTP

Issue: [[https://codeberg.org/spritely/goblins/issues/50][#50]]

When a node connects to another node in Goblins it provides the
location from where it's accessible (i.e. the OCapN node address). One
feature of OCapN is to ensure only one connection exists to any given
node, since the address provided by a new incoming connection is never
authenticated, this could lead to a denial of service by a malicious
actor claiming to be a node it is not.

** v0.14
*** Highlights
- New libp2p netlayer
- Intra-vat persistence support
- Persistence support in netlayers
*** New features and improvements
**** New libp2p netlayer

Libp2p is a peer-to-peer network stack which backs IPFS, Filecoin and other
peer-to-peer applications. You can now use libp2p as a netlayer within Goblins,
by spawning the =^libp2p-netlayer= actor from =(goblins ocapn netlayer libp2p)=.
Since there isn't a libp2p library directly in Guile, the netlayer relies upon a
daemon written in Go, you can find that here:

https://codeberg.org/spritely/go-libp2p-daemon

**** Intra-vat persistence support

Many improvements have come to the persistence system in this release, perhaps
the most significant is allowing persisting far references, this is references
to objects which live on other local vats. This is done by a new actor,
=^persistence-registry= which each vat registers with and coordinates the
restoration of each vat asynchronously.

Usually in its own vat (does not need to be persistence aware), you spawn a
persistence registry, you then pass this into each persistent vat using the
=#:persistence-registry= keyword. Since vats can be spawned at any time during
the program's lifetime, the persistence system resolves far references to
promises which may resolve when the coordination has completed.

**** Persistence support in netlayers

Netlayers now support the persistence system. Goblins now handles storing and
providing the secrets and other information a netlayer might need to persist the
connection. To enable this just spawn the netlayer within a persistent vat and
provide a store and everything will be handled automatically, just like working
with any other persistence aware actors.

*** Bug fixes

- Fixes issue where multiple connections would be made when enlivening two
  sturdyrefs to the same node when no connection existed prior.
- Vats with logging disabled no longer take a snapshot each churn.
- The =all-of*= joiner will now resolve when given an empty list of promises.
- =on-sever= promises will be immediately broken if the CapTP connection has
  already been severed.
- Fix issue where IO actor procedures would assume optional init and cleanup
  procedures where always provided.

*** Known issues
**** Prelay connections are unencrypted and unauthenticated

Messages sent through the Prelay netlayer can be viewed by the relay server,
modified and new messages inserted by the server or silently removed and thus
not delivered by the Prelay netlayer.

This means that you should only use the Prelay netlayers where you can place
high trust in the relaying server.

**** Lack of dialback within CapTP

When a node connects to another node in Goblins it provides the location where
it's accessible (i.e. the OCapN node address). One feature of OCapN is to ensure
only one connection exists to any given node, since the address provided by a
new incoming connection is never authenticated, this could lead to a denial of
service by a malicious actor claiming to be a node it is not.

** v0.13
*** Highlights
- New persistence system
- New IO actors
*** New features and improvements
- Refactored syrup sets into gsets located in =(goblins ghash)=
- =(goblins actor-lib selfish-spawn)= is now documented.
**** New Persistence System

The new persistence system provides a mechanism to safely serialize
and restore actors within a graph. Actors defined with the new
=define-actor= macro, or by using the manual mechanism by specifying a
self-portrait function are able to be serialized, saved and then
brought back. This makes handling building systems which need to
shutdown a easy and safe saving mechanism.

Due to how the persistence system works, it also allows for upgrading
of actor behavior and state. It also allows for a more powerful live
hacking experience by allowing object definitions to be changed and
then all objects of that type to be upgraded to the new definition
while keeping their references the same.

The system works with both actormaps and vats and comes with a syrup
file based store and a in-memory store.

**** IO Actors

A new actor-lib library (=(goblins actor-lib io)=) has been added
which makes interacting with external IO resources (or possibly other
resources) much easier and more natural within Goblins. It abstracts
the Fibers details and provides an actor which you're able to message
and receive promises like you'd expect from Goblins' actors.

*** Bug fixes
- Fixes possible problem with the =^nonce-registry= actor not having
  time consistent lookup times.
- Fix race condition during in churns when using =call-with-vat=.
- Fix timeout issue in some tests caused by
  =resolve-vow-and-return-result=
- Fix issue sending =*unspecified*= across CapTP.
- Fix ordering issues for expected and actual in tests.
- Improves error messages when invalid OCapN URIs are parsed.
*** API Changes
- The function to swap the swappable proxy from =(goblins actor-lib
  swappable)= has now become an actor.
- When supplying custom sealers to =(goblins actor-lib sealers)= they
  must be defined in a known sealers alist.
*** Known issues
- [[https://codeberg.org/spritely/goblins/issues/191][#191]] Objects defined with =define-actor= do not retain their docstrings
- selfish-spawn does not work with new persistence system
** v0.12
*** Highlights

- New Prelay netlayer
- New TCP-TLS netlayer
- Various fixes and enhancements to CapTP support
- A new Queue (FIFO) actor in our actor-lib library

*** New features and improvements
**** Prelay Netlayer

The Prelay netlayer (the "preview of relay" netlayer) is a new netlayer using
the existing netlayers, it's designed to have a relay server and relay
client. This works especially well with, for example the new TCP-TLS netlayer as
often users will be behind firewalls and routers which require special
configuration to allow for peer-to-peer connections.

This new netlayer hopefully will help connect more nodes who otherwise couldn't
have connected to each other. It's currently an early version of itself with
some limitations, those being that traffic is unencrypted and unauthenticated,
something akin to IRC or vanilla ActivityPub. It currently requires trusting the
relay server, however in the near future we will be looking to address those
limitations.

**** TCP-TLS Netlayer

This netlayer supports connection over TCP sockets with encryption built in with
TLS. Unlike the tor netlayer which requires extra software (the Tor daemon) and
configuration, this allows for both simpler and quicker communication between
two nodes. Encryption occurs with self signed certificates. This netlayer works
particularly well with the new Prelay netlayer as often making peer-to-peer
connections is difficult due to firewall or router configurations.

**** Improved CapTP support

There has been multiple fixes and enhancements to CapTP support, which are:

- Crossed hellos mitigation (when two nodes try to connect to each other at the
  same time)
- Removal of the now deprecated =op:bootstrap= operation (this is now done by
  always exporting the bootstrap object at position =0=).
- Verification of the handoff count on Third Party Handoff certificates.

In addition, the [[https://github.com/ocapn/ocapn-test-suite][OCapN test suite]] can be now run. There is the test support
added to examples/ocapn-test-suite.scm which when run provide a OCapN node
address which can be provided with the test suite to allow the suite to run.

**** A new Queue actor

This new queue actor exists =(goblins actor-lib queue)= and represents a queue
(i.e. FIFO) where new items can be queued or removed. Please refer to the new
documentation to see how to use this.

*** Bug fixes

- Fix =live-guile.sh= live hacking script when certain Geiser incompatible
  configurations were in the =.guile= config file.
- REPL test is fixes when locale has a limited character set.
- Fix bug in =install-netlayer= method on mycapn which used an invalid method
  causing it not to work.

*** Known issues
**** Prelay connections are unencrypted and unauthenticated

Messages send through the Prelay netlayer can be viewed by the relay server,
modified and new messages inserted by the server or silently removed and thus
not delivered by the Prelay netlayer.

This means that you should only use the Prelay netlayers where you can place
high trust in the relaying server.

**** Lack of dialback within CapTP

When a node connects to another node in Goblins it provides the location where
it's accessible (i.e. the OCapN node address). One feature of OCapN is to ensure
only one connection exists to any given node, since the address provided by a
new incoming connection is never authenticated, this could lead to a denial of
service by a malicious actor claiming to be a node it is not.
** v0.11

*** Highlights

 - New time-traveling distributed debugger
 - Substantially improved documentation and docstrings
 - Several more actor-lib modules ported from Racket to Guile
 - Updates to OCapN code

*** New features and improvements
**** Time traveling distributed debugger

Goblins now includes a time traveling distributed debugger!  Yeah, you
heard that right!

The new Goblins debugger allows programmers to inspect and debug
distributed computations that happen across many vats (communicating
event loops.) The time travel feature allows for visiting past events
and inspecting program state at the time the event happened.

These tools are implemented as “meta-commands” for Guile's REPL,
complementing the tools that Guile already provides for sequential
debugging. In true Scheme fashion, this means that debugging happens
live, while the program is running, allowing programmers to fix bugs
and try again without having to stop and recompile/reboot their
program.

Blogpost, with examples:

  https://spritely.institute/news/introducing-a-distributed-debugger-for-goblins-with-time-travel.html

**** Documentation overhaul

Documentation has received a major overhaul in this release:

 - All key procedures now have docstrings, allowing for easier
   discovery of API usage during development
 - The manual's tutorial has been cleaned up for clarity and
   correctness
 - All core API procedures are now documented in the manual
 - All modules in the actor-lib are now documented in the manual
 - The manual now has an index, so finding procedures is much
   easier

**** More actor-lib libraries ported from Racket version of Goblins

 - =(goblins actor-lib pushdown)= is a simple pushdown automata
   implementation, useful for various kinds of state machines,
   especially in some games
 - =(goblins actor-lib opportunistic)= allows for proxying object
   behavior, opportunistically using =$= for near objects but using
   =<-= otherwise (known as select-swear in the Racket version)
 - =(goblins actor-lib simple-mint)= is a very simple example
   "bank" of sorts, ported from the example in
   [[http://erights.org/elib/capability/ode/index.html][An Ode to the Granovetter Diagram]]
 - =(goblins actor-lib let-on)= provides convenient code for promise
   resolution which strongly resembles =let= in Scheme, but with the
   behavior of =on= in Goblins

**** ,vats repl meta-command

It's now possible to list which vats are active via the =,vats=
REPL command.

**** OCapN / CapTP updates

Work has continued on Goblins' implementation of OCapN, the Object
Capability Network, the set of network abstractions which provide
the fluid experience of distributed networked programming.

Goblins' network architecture is still in active development; this
release breaks compatibility with the =0.10= release of Goblins.

***** Semantics closer to CapTP draft specification

Goblins' implementation of the OCapN version of CapTP (the Capability
Transfer Protocol) is aimed to be used as the starting point for
revisions for the OCapN group.  We have submitted a
[[https://github.com/ocapn/ocapn/pull/42][draft version of the protocol]] to the OCapN group.  Goblins 0.11 gets
us closer to the aims of that draft; we are hoping within the next few
releases to get full alignment and group consensus towards a unified
OCapN protocol, and the =0.11-goblins= release of OCapN and CapTP
shipped with Goblins gets us closer to that goal.

***** Add acyclic distributed GC support to CapTP

Goblins 0.11 now ships support for acyclic distributed garbage
collection, meaning that references to cooperative freeing of objects
shared over the network but no longer needed is possible

**** Facets use opportunistic synchronicity now

=(goblins actor-lib facet)= has been updated to use
=(goblins-actor-lib opportunistic)=.  In effect, this means that
the =#:sync?= keyword has been removed; facets now automatically
do the right thing.

*** Bug fixes

**** Backtraces which hung backtrace printing fixed

Previously certain backtraces would break and could hang Goblins.
This was due to a bug in Fibers in conjunction with Guile's backtrace
printer.  We have introduced a workaround which strips the frames
which would break Goblins.  The additional advantage of this fix is
that backtraces printed by Goblins are now significantly cleaner
with irrelevant information reduced.

**** Avoid explosion of threads on creation of new vats

Previously, new schedulers were accidentally made every time
new vats were made.  This would lead to an explosion of threads,
sometimes causing Guile to crash abruptly.  This bug is fixed.

**** Minor fixes

 - Bad reference to ^broken-ben in tutorial fixed
 - Nondeterministic test failures fixed
 - Sealers now print using correct port

*** Deprecations

 - =define-vat-run= is now deprecated, use =call-with-vat= or
   =with-vat= instead.

*** Known issues

 - Two machines simultaneously opening connections to each other on
   the OCapN network through Goblins fail to behave correctly.  This
   is known as the "crossed hellos" problem.  We are hoping to have
   this fixed in the next release.
 - We are still working towards full compatibility with the
   OCapN CapTP draft specification.

*** Thanks

David Thompson
Juliana Sims
Christine Lemmer-Webber
Jessica Tallon (Racket code ported to Goblins)
Vivianne Langdon
Geoffrey J. Teale

** v0.10

*** New features and improvements

**** OCapN support and interoperability with Racket Goblins

Guile Goblins has been updated to speak the OCapN protocol, finally
allowing Guile users to be able to easily make awesome
object-capability-secure peer-to-peer programs!  Furthermore, the
OCapN implementation is compatible with Racket Goblins, allowing both
flavors of Goblins to interoperate with each other.

**** Vats are now record types supporting custom event loops

Vat objects used to be procedures that could be passed various
arguments to interact with the underlying fiber managing the vat.
Now, vat objects are a SRFI-9 record type and can be inspected using
procedures like =vat-name=.  =call-with-vat=/=with-vat= provide the
new interface for applying thunks within a vat.

Additionally, the default fibers vat implementation has been separated
from the core vat code, allowing custom vats to be implemented on top
of other asynchronous event loops.

See the manual for full details.

**** New ,enter-vat REPL meta-command

The new =,enter-vat= meta-command, which is automatically added to
REPLs when the =(goblins)= module is imported, allows evaluating code
within the context of a specific vat.  Errors generated within a vat
while evaluating an expression are propagated to the REPL for
debugging.

**** Expanded documentation

Much of the API surface has now been documented, including several
actor-lib modules and the OCapN API.  Additional examples and
instructions for setting up the Tor daemon have been added, as well.

**** More actor-lib libraries ported from Racket version of Goblins

New modules:

 - =(goblins actor-lib facets)= for attenuating capability methods
 - =(goblins actor-lib joiners)= for resolving one or multiple promises
   (=all-of= and =all-of*= anyway, =any-of= still needs to be ported)
 - =(goblins actor-lib pubsub)= for publish-subscribe
 - =(goblins actor-lib sealers)= for actor-based sealers/unsealers
 - =(goblins actor-lib ticker)= for a collection tool useful for game
   engines with many objects that need to be updated in a tick

*** Bug fixes

 - Message order across vats was previously incorrect after completion
   of a churn
 - =extend-methods= previously re-executed the extended code upon every
   invocation which was incorrect and error-prone
 - Various fixes to syrup library

*** Known issues

**** Fibers and backtrace printing

guile-fibers >= 1.1.0 has a bug related to exception handling that
causes backtrace printing to fail.  Goblins has worked around this by
omitting backtrace printing in certain situations.  See
https://github.com/wingo/fibers/issues/76 for more information.

** v0.6

This is the first release of Spritely Goblins on Guile.
There's not much to say in terms of "differences" from the previous
version of this package, since this is the first release.  Relative
to the [[https://docs.racket-lang.org/goblins/index.html][Racket version]], this library is at a fairly early stage.

That said, much of the functionality is here: actors/objects,
synchronous and transactional invocation via =$=, asynchronous
message passage via =<-=, promise pipelining, etc etc.

The main things that are missing are:

 - Easier ways to start up a vat for a more serious program (not just
   experimenting at the REPL)
 - A more fleshed out actor-lib
 - Most significantly, a working version of CapTP.

More soon.
