[Haskell-cafe] [ANNOUNCE] Ajla: a new purely functional programming language

[Mikulas Patocka]

On Mon, 27 May 2024, jo at durchholz.org wrote:

> On 26.05.24 23:57, Mikulas Patocka wrote:
> > Hi
> > 
> > I'd like to announce the release of Ajla - a new purely functional
> > programming language that looks like traditional procedural languages.
> > 
> > If you are interested, see https://www.ajla-lang.cz/
> 
> Just one thing that caught my eye:
> 
> > Ajla has efficient mutable arrays - if an array's reference count is one,
> the array is modified in place. If not, a copy of the array is created and
> modified.
> 
> That design decision restricts you to reference-counting garbage 
> collectors. These have multiple problems and restrictions, such as:
> - Inability to deal with reference cycles.

You can create circular lists in Haskell, but not in Ajla. I.e. the 
statement "var cycle := [ 1, 2, 3 ] + cycle;" won't compile, because the 
variable cycle is not known.

> - Assigning to a reference means TWO additional write operations to keep 
> the reference counts up-to-date; this means your programmers will try to 
> minimize allocation, which tends to restrict the design space so the 
> code gets worse.
> - Reference counting is less efficient than copying collectors for most 
> cases.
> - Being restricted to one GC algorithm means the language cannot improve 
> on that front, the GC approach is baked into the language semantics and 
> cannot be changed if it turns out it was an unlucky choice.

Ajla has possibility to bypass the reference counting - if the refcount is 
-1, it means that the object is stored in a read-only memory-mapped file 
and the refcount won't be updated at all.

So, if I find some workload where there would be many threads massively 
thrashing on the same reference count, I could set it to -1 and let some 
primitive GC free it. So far, I haven't found such a workload, so I 
haven't implemented it.

> I'd recommend doing something like the borrowing semantics in Rust, or 
> uniqueness typing of Clean: Some language mechanism that makes sure that 
> all mutable data is only accessible through a single reference at any 
> one time.

If you use arrays in the same way as unique types, there would be no 
refcount modification. I.e. if you pass an array to a function and stop 
using it in the parent function, there is refcount increment followed by 
refcount decrement - and the optimizer will fuse these two refcount 
operations into nothing.

> This will also allow compilers to aggressively optimize, since if a 
> language enforces a one-reference-to-mutables-only, there can be no 
> aliasing, and that's a huge win as any even merely potential aliasing 
> prevents a whole host of important optimizations.

I've written SSA-based optimizer for Ajla (see the file 
newlib/compiler/optimize/ssa.ajla) and it was surprisingly easy because 
there is no aliasing. From the user's point of view, every variable can be 
modified independently. Modifying a single variable doesn't modify any 
other.

Mikulas

> Just my 2c :-)
> 
> Regards,
> Jo
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.