tip

This is an unreleased snapshot built from the main branch. Like a nightly but more up to date.

Added

• More unboxing of fixed size integers
  • Function local variables are unboxed
  • Passing fixed size integers as arguments between functions is also unboxed
  • This adds an extra pass to the compiler to handle boxing and unboxing
  • For some programs, the code is now pretty much optimal
    • For example, the C code generated from test/perf/src/dct.act looks
      pretty much as one would write it by hand and thus runs at about the
      "speed of C". It does 0 mallocs and runs about 20x faster than before
      unboxing (depending a bit on computer).
  • class and actor attributes are still boxed
    • This is likely the most important future work around unboxing since
      individual mallocs for class & actor attributes typically account for a
      the lion's share of GC pressure
    • It is challenging around generics though
• New Set.update() method to add items to a set from an iterable, such as a
  list or another set
• Added --module argument to acton test to select module to test
  • For example, acton test --module foo to only run tests in module foo
• Improved printing of test results for test modules that crashed
  • The error is now printed for each individual test in the test module
• Added list.index(val, start=0, stop: ?int) to get the first index of an
  element in a list. It can be constrained through the start and stop
  parameters.

Changed

• re.match() now returns Match object where the group is list[?str]. It
  used to be list[str] but it is possible to have groups that do not match on
  anything and so ?str is the correct type. This applies both for named groups
  and normal numbered groups.
  • For example, consider foo((123)|bar) which matches either foo123 or
    foobar. The inner (123) group is ORed and so it will have no match for
    foobar, thus we get the result m.group = ["foobar", "bar", None]
• set.pop() now throws ValueError for an empty set

Fixed

• Fixed tuple type inference
  • Tuples with named fields can now be properly type inferred
• acton test perf now limits concurrency to 1 to get better results
• Fix str.strip() on empty strings, it would previously return \n but now
  returns an empty string as it should
• Fixes crash in re.match() for groups with no matches, which previously
  resulted in SEGFAULT
  • For example, consider foo((123)|bar) which matches either foo123 or
    foobar. The inner (123) group is ORed and so it will have no match for
    foobar, thus we get the result m.group = ["foobar", "bar", None]
    • This would previously crash but we now properly check the result values
• Fix str slicing when range is 0 length which would previously SIGILL
  • For example, for a = "foobar" if we would try to access a[23:], there is
    no character 23 and so the length of the slice is 0 which would trigger a
    SIGILL when compiled in --dev mode (which comes with lots of extra
    UBsan)
• Fix dict corruption issue #1805
• set.pop() now does not crash for an empty list (it threw NULL before)
• Fix decoding of buffered test output

Testing / CI

• Added performance test to CI
  • This runs on a dedicated computer, a laptop in Kristian's rack at home
  • Runs acton test perf in test/perf which currently only includes the
    dct program
    • Simply add more test programs to the test/perf project to have them run
  • The testing procedure is as follow:
    • The CI test checks out the tests from the feature branch, so it will
      always be the latest version of the test itself
    • The latest tip release from acton main branch is installed and used to
      compile the test/perf project
    • acton test perf --record is used to run the test and record the result,
      which will act as the baseline
    • The acton release from the local feature branch is then installed (fetched
      as artifact from the build-debs job)
    • acton test perf is now run, which will run with the latest version and
      compare the results against the baseline
    • We do not currently inspect the results to give a pass / fail score,
      they're just printed in the CI output for a human to look at
    • Natural variance seems to hover around +-5%, which feels OK
• Revamp PR testing to run on small set of platforms and run a nightly scheduled
  test job that includes all platforms that were previously in the PR jobs
  • This was triggered by the number of platforms reaching a higher number which
    in turn has led to more cached data and as the GitHub Actions runner cache
    is limited to 10GB, we hit the limit and got churn which meant that there
    were always slow jobs. By reducing the number of PR jobs, they can continue
    to run cached whereas the nightly jobs can run without a cache.
• Stop CI testing on MacOS 11 as it has been deprecated by Github
• Start CI testing on Ubuntu 24.04
• Stop CI testing on Ubuntu 23.04 and 23.10 as they are EoL
• Temporary fix of building Acton by using our own mirror for the Zig tar ball.
  We are using a particular nightly v0.12.0 build that is no longer available
  for download from ziglang.org and so we now mirror it ourselves. This affects
  both builds in CI and local builds.
• Fix GitHub Actions to run on Ubuntu 18.04
  • The artifact download action uses Node.JS to run and as GitHub has imposed
    constraints and new defaults, this has been magically updated to use a newer
    version of Node.JS than before. The newer Node version is compiled using
    glibc 2.28 and that's too new for Ubuntu 18.04, so the end result is that
    you basically can't use the common GitHub Actions with Ubuntu 18.04 or
    similar older distros. What a weird way to treat your CI users by GitHub!?
    Anyhow, we work around this by explicitly enabling the use of the old Node
    again.

v0.22.0

Support for Windows and continued improvements for acton test! Internally the
biggest change is the removal of link time redirection of malloc, which opens up
for more flexible memory management.

Added

• Acton programs now run on Windows!
  • It is now possible to compile Acton programs for Windows, both x86_64 and
    aarch64, although since Acton itself (compiler etc) is not available on
    Windows, only cross-compilation from MacOS or Linux is possible.
  • Use acton --target aarch64-windows-gnu examples/helloworld.act to produce
    examples/helloworld.exe which can be run on Windows
  • Acton applications compiled for Windows are single threaded
  • termios related terminal settings, is not supported on Windows
• Acton RTS now supports actor cleanup through GC finalization
  • Define a action def __cleanup__(): action on your actor and it will be run
    when the actor is about to be garbage collected
• acton build now builds dependencies in deps/ before building the main
  project
• acton test now excludes the time spent in GC from test times
  • This is probably somewhat approximate and not super accurate, in particular
    for tests with very short test durations
• acton test perf is now expanded and support all kinds of tests (previously
  only unit tests were supported)
  • some memory usage is printed alongside timing information
  • GC is run explicitly during perf test to get better memory usage stats but
    it also slows things down a bit, in particular for very short duration tests
• acton test perf --record can save a performance snapshot to disk
  • Subsequent invocations of acton test perf will back the data from disk and
    display a comparison with percentage diff
• AbE: testing documentation is much improved!
• acton --only-build performs only the low level build from .C source,
  skipping compilation of .act files. This can be used if you want to modify the
  C source by hand and still leverage the low level builder to perform the build.
• file.FS.cwd() to get current working directory
• file.join_path() to join path components
• Link time redirection of malloc & friends is now removed. All malloc calls are
  instead explicit, either directly to GC_MALLOC or via acton_malloc which
  is our own malloc function which is runtime reconfigurable. While there is no
  usage of malloc directly from our code, it is now possible to do manual
  memory management mixed with GC managed memory.
  • As before, module constants are placed in the regular heap, so that the GC
    does not have to scan it.
  • Many string formatting functions have been reshaped since asprintf does an
    implicit malloc, which we must either free or avoid. As a result, we now
    copy less data around, which speeds things up.
• process.Process now takes an optional timeout argument to stop the process
• New process.RunProcess that waits for a process to exit and then reports to
  a callback with the buffered output from stdout / stderr
  • This can provide a simpler interface than process.Process if you just want
    to wait for the process to finish running before starting to parse its
    output as you'll get a single invokation and the full output rather than
    receive it piecemeal
• Add .unix_s() .unix_ms() .unix_us() .unix_ns() to time.Instant
  • To get a Unix timestamp (seconds since 1970-01-01 00:00:00), as seconds,
    milliseconds, microseconds or nanoseconds respectively
• env.is_tty() to check if stdout is a TTY
• acton.rts.start_gc_performance_measurement() to start a GC perf measurement
• acton.rts.get_gc_time() to get the GC timings
• env.is_tty() to check if stdout is a TTY
• env.set_stdin(canonical: bool, echo: bool) to set stdin options
  • canonical is the default mode which is line buffered where the OS /
    terminal offers line editing capabilities and we only receive the input ones
    carriage return is hit
  • setting env.set_stdin(canonical=False) turns stdin into non-canonical mode
    where each character as entered is immediately forwarded to the stdin
    callback so we can react to it, great for interactive applications!
  • echo enables (the default) or disables echoing of characters
• term improvements:
  • More grey shades
  • term.clear && term.top to clear and move cursor to top
• http.Client.close() to explicitly close a connection
• Single threaded RTS mode, only used by Windows for now

Changed

• The work dir and environment arguments of process.Process have been moved to
  the end as they are optional, making it possible to invoke with fewer args
• Tests run by acton test are now compiled with --dev and thus have C
  asserts enabled, similarly the test.hs that drives the test in the Acton repo
  now compile with --dev to get C asserts
• acton test now runs test for at least 50ms
• acton test perf now runs test for at least 1s
• Rename --only-act to --skip-build
• Acton build cache now uses up to 15GB instead of 5GB

Removed

• actonc no longer supports --no-zigbuild / --zigbuild (it's now the
  default/only choice). It hasn't been tested in quite some time now and the zig
  build system works well enough that there is basically no reason to keep the
  old system around.
• actonc no longer accepts --cc since we now always build using the zig
  build system which implies the clang version that Zig ships.
• actonc no longer supports explicit --stub compilation, use --auto-stub

Fixed

• key argument in KeyError(key) is now of type value, not list[None]
  which it was previously incorrect inferred as
• file.WriteFile.write() now truncates file to avoid leftover tail of old
  content
• time.Stopwatch().reset() now works
• Test crashes are now handled
  • If the test program (e.g. ._test_foo) crashes from an assert or similar,
    the top test runner now captures this and reflects it in the output
• Correct dependency path computation in builder
• Makefile now more idempotent to avoid building when nothing has changed

Testing / CI

• Test on MacOS 14 on Apple M1 / arm64 / aarch64
• Many tests are now repeatedly 100 times to give some idea of stability

v0.21.0

Added

• acton test testing has been revamped, now doing multiple test iterations
  • each test will be run for at least 1ms, for many smaller unit tests this
    means the test case run hundreds of times
  • all the internals have been rewritten to handle multiple tests results from
    a test
  • running multiple test iterations gives better performance measurement but
    can also show flakiness in tests
• acton test list will list all the test names in a project
• acton test --name foo --name bar will filter to only run tests named foo
  and bar in a project
• AbE: explain testing with acton test
• New methods to interact with environment variables [#1723]
  • getenv & getenvb to read an environment variable
  • setenv & setenvb to set an environment variable
  • unsetenv & unsetenvb to set an environment variable
  • The first set of functions work with strings and attempt to automatically
    detect the encoding, although utf-8 is the only supported encoding by Acton
    right now.
  • The functions ending with b work with bytes data which can be used for
    explicit control over encoding.
• env.stdin_install now supports both str and bytes [#1723]
  • It was orignally built to work with str which meant it decoded data from
    stdin automatically. This assumed utf-8 encoding.
  • env.stdin_install was then changed so the callback would get bytes,
    which is technically more correct (it could just be bytes!) but leaves it to
    the application programmer to decode data.
  • A new interface now offers the best of both worlds:
    • env.stdin_install(on_stdin, encoding, on_stdin_bytes)
    • by specifying env.stdin_install(on_stdin=my_cb), my_cb will be called
      and get str input. The encoding is detected by reading the LANG
      environment variable or defaults to utf-8. It is possible to explicitly
      specify the encoding with the encoding argument.
    • Use env.stdin_install(on_stdin_bytes=my_cb) to instead receive bytes
• Acton now always compiles everything from source
  • Previously, pre-compiled binary libraries were shipped for the native
    target, so on x86_64-linux, there was a libActon.a compiled for x86_64-linux
  • Now we just ship the source code of Acton base etc and perform the full C
    compilation when we actually run actonc
  • The first invokations of acton build is slow, taking up to a few minutes,
    but as all results are cached, subsequent invokations run in fractions of a
    second.
  • ~/.cache/acton is used to store the cache and it is wiped if it reaches
    5GB after which it will be automatically re-populated when the next acton build is called
• Low level compiler support for dependencies
  • Place Acton project dependencies in the deps/ folder and the compiler will
    automatically find them to allow inclusion of Acton modules from other Acton
    projects
  • This implements the low level internal support for finding modules in other
    projects and correctly linking together the final output
  • There is NO support for managing the dependency download itself or even
    compiling the dependency
• SIGABRT is now automatically handled by the crash handler for automatic
  backtrace printing or interactive debugging, just like we already manage
  SIGILL and SIGSEGV
  • This simplifies debugging of Acton itself after catastrophic crashes
• file module now has methods to interact with file system, like listing
  files, making directories, stating files, removing files and walking directory
  trees.
• file.FS.exepath() returns the path to the current executable
• acton now finds actonc by looking at its own location rather than assuming
  actonc is on the path
• Add --only-act to only perform Acton compilation and skip C compilation

Changed

• acton test will compile test functions in dev mode to get asserts
• The dev and rel folders have been removed, e.g. out/rel/bin -> out/bin
• Printing of compiler pass debug output from individual files, like acton src/foo.act --types will now only print output from the specified name and
  not dependencies
  • Previously, dependent modules, like if src/foo.act imports bar, we would
    also print the types debug output for the bar module
  • Printing of compiler pass debug output requires recompiling the module and
    thus shortcutting the up-to-date check. By not printing output for included
    modules, the included modules do not need to be recompiled thus speeding up
    the whole compilation.
• Always link in libprotobuf-c to allow modules to use protobuf tech
• Improved argparse parsing by doing a descent first parsing of options and into
  sub-commands with positional argument parsing happening as a second pass
  [#1714]

Fixed

• acton new foo now creates a new project foo
• Fixed handling of failing tests in acton test [#1709]
• Fixed required since self is now parsed as a kwd param [#1715]
• Upgrade GC
  • Now ignoring free(). This was also previously the case but this was lost
    when we upstreamed the new build.zig for bdwgc. It is now back, which is
    required for handling the "edge", like where syscall / libc calls do malloc
    and then free. uv_fs_scandir is an example of such, which was recently added
    and triggered a bug.
  • Incremental collection has been fixed on Linux so that it should work,
    although it is not supported by the Acton RTS. Incremental collection is
    likely much slower for most programs but with better responsiveness. It
    could potentially be better for very large heaps as well as overhead of
    virtual dirty bit now only hits from a very small heap. It remains to be
    seen.
• testing.test_runner has been fixed with regards to scheduling, now we
  actually wait for a test kind to be completed before proceeding to the next.
  Previously for async tests we would spawn all tests immediately and then
  proceed to next test category, so we would oversubscribe the tests runners
  giving worse performance.
• Various fixes to test output, like count of tess was wrong
• numpy now compiles and runs. There are new tests cases!

Testing / CI

• Tests, like of builtins etc, now run with --dev so we get assertions

v0.20.1

Fixed

• Install acton frontend in Debian package

v0.20.0

Added

• New acton CLI which takes over as the main acton program, it should be
  called instead of actonc, for example acton build [#1645]
  • it calls into actonc for doing most of the work and is currently mostly
    just a thin wrapper
  • over time, more functionality will be placed in the acton frontend
• New acton test command which build and runs all test in a project [#1645]
• The compiler now does automatic test discovery
  • Simply doing import testing and functions with a name starting with
    _test will be identified as a test and run by acton test. The functions
    are sorted into categories based on their type signature.
• Run-time reconfigurable malloc
  • It is now possible to reconfigure which malloc to use during runtime
  • All external libraries (libuv for example) are now configured to use a
    particular malloc
  • Libraries that did not support a custom alloc have now been extended with
    support for custom malloc.
• Module constants are placed in non-GC heap
  • Using the reconfigurable malloc, we now make use of the "real" malloc (the
    one libc provides) during startup of RTS and up past module init. This means
    all module constants will be placed on the normal heap and not the GC heap.
  • The GC is mark & sweep which means it slows down considerably when there is
    a large live heap.
  • This makes is a viable option to place large amounts of data as module
    constants instead of run time state to speed up programs.
• Fixed size integers arithmetic and comparisons are now unboxed
  • For math heavy programs, this can produce a 4x improvement
  • A lot of witnesses are now unnecessary and thus removed, reducing GC pressure
• testing module has gotten a face lift with much better asserts
  • The assert exceptions now include and print the values
  • Formatting happens in __str__ so performance of exceptions is unchanged
• New snappy module in stdlib [#1655]
  • Snappy is a fast compression library
  • Snappy is written in C++ which implied some changes to build.zig and actonc
• It is now possible to print a .ty file by doing: acton foo.ty
• Improved size & performance of dictionaries
  • An empty dictionary is now completely empty
  • For low number of elements, the dictionary is actually a list with linear
    searching
  • For 5 elements and up, the dict starts to use a hashtable
• KeyError & IndexError now include key / index so it's easier to
  understand what went wrong

Changed

• The Debian package of Acton now depends on libc 2.27 [#1645]
  • Previously depended on the glibc installed on the the build machine (2.36)
    since it was expanded from ${shlibs:Depends}
• Now using Zig 0.12.0-dev.2236
  • the build system has changed somewhat so all build.zig files are updated
• DB backend is now optional, include with acton build --db
• Using newer version of tlsuv library
• RTS main thread now runs special actors, currently just Env
  • This enables us to install signal handlers from Env since this must be
    done from a programs main thread.

Fixed

• dict changed internally to allow storing of None
• Support None in JSON
  • Based on the improved support of dicts
• lstrip, rstrip & setdefault now work properly
• Fix effect of json.encode() and json.decode() [#1654]
  • They are pure!
• Fix testing.test_runner when there are 0 tests to run [#]
• Add tests of client & server in http module
• argparse module now supports nested command parsing
• argparse module now supports -- for literal interpretation of positional
  arguments
• Fix compilation of projects that used TLS
  • We had missed linking in all necessary mbedtls libraries

v0.19.2

Added

• argparse now supports optional positional arguments
  • like so: p.add_arg("foo", "Foo thing", required=False, nargs="?")
• print() now takes multiple new input arguments:
  • print(*vals, sep=" ", end="", stderr=False, flush=False)
  • sep is the separation character between values, default " "
  • end is the line ending character, default "\n"
  • Output is written to stdout per default, set stderr=True to write to
    stderr instead
  • set flush=True to flush the output
• new --rts-bt-debug flag that launches interactive debugger (gdb) on
  SIGSEGV / SIGILL

Changed

• print() now formats to a temporary buffer before printing to reduce
  interleaving multiple outputs
• printn() has been removed in preference of using print(foo, end="")

Fixed

• KeyError now includes the key as part of the error message
  • e.g. KeyError: getitem: key not in dictionary, key: foobar
  • The string formatting of the error message including the key only happens
    when the str representation of the exception is necessary, so it does not
    incur a performance penalty in normal scenarios
  • The key for which the lookup was attempted is stored in the key attribute
• Homebrew Formula now somewhat decoupled from Stack version [#1627]
  • Idiomatic Homebrew Formulas use system-ghc, i.e. a GHC version installed by
    Homebrew itself and not from Stack. Since we specify a Stack LTS resolver,
    which is a coupled to a particular version of GHC, there is room for a
    version mismatch.
  • The latest occurrence of which was GHC 9.4.8 in Homebrew vs Stack LTS 21.13
    with GHC 9.4.7. A rather silly small mismatch but that nonetheless breaks
    the Homebrew build. This is particularly annoying because it happens only
    after we've made a release, so the feedback is too late and thus a
    correction version must be released to fix the version mismatch (we've
    upgraded to LTS 21.25 with GHC 9.4.8 to align on Homebrew).
  • Now skip-ghc-check is used to skip the GHC version check to allow some
    minor mismatch to happen. We must still ensure that at least the major
    version of GHC is aligned, like GHC 9.4.

v0.19.1

Fixes

• Upgraded Stack to 21.25 / GHC 9.4.8
  • This should hopefully fix the Homebrew build

v0.19.0

Added

• Much improved argument "rows" support [#1609] [#1617], including:
  • positional & keywords arguments
  • default argument values
• up, down, left & right in term module now accept n arg [#1619]
  • can move multiple steps in given direction

Changed

• for http.Client the following positional arguments are now keyword args:
  • schema: defaults to https
  • port: defaults to 80 for schema http and 443 for https
  • tls_verify: default True
  • connect_timeout: default 10.0

Fixes

• Remove superfluous explicit arguments, now using default values [#1615] [#1618]
• Now possible to print None [#1609]

Testing / CI

• Now testing Telemetrify in GitHub Action workflow as part of CI testing
  • Telemetrify is the largest known application written using Acton, so we add
    testing of it to the Acton repo to avoid accidental breakage
  • Telemetrify main branch is already tested with the latest release of Acton
  • now, new changes in acton are also verified against the telemetrify repo
  • we test against the acton-next branch in the telemetrify repo
    • this enables us to make breaking changes in the Acton repo, realize the
      break, then write a fix adapting the telemetrify code to the new Acton
      change and push this to the acton-next branch after which the PR on the
      Acton repo can be retried

v0.18.5

Testing / CI

• Fix build of APT repo

v0.18.4

Fixes

• Add constraint forcing type of self parameter [#1598]
• Let solver use upper bound of type variable when reducing protocol constraints
• Remove subclass constraint on isinstance parameters
• Type error message improvements [#1522] [#1589] [#1596]
• Fix actonc --debug [#1591]
  • Now also printing zig output
  • --verbose has been removed

Testing / CI

• Stop testing on MacOS 11 [#1600]
  • Homebrew has dropped support for MacOS 11 so the CI job had to build stuff
    from source making it super slow and fragile, thus dropping it.