alt.hn

And I don't quite understand the memory model, is it something similar to Rust?

by mapcars

We ferment wine or beer in a different vessel with different airlock, so it does not blorp. We don't have a word for that yet.

The crock we used that birthed this word is this one:

https://www.lehmans.com/product/striped-european-style-ferme...

by mauvehaus

Perhaps it's just one point from me - not liking chaining :D

by cupofjoakim

  thing
    .doThis()
    .thenDoThat()
    .andFinallyThis()

  andFinallyThis(
    thenDoThat(
      doThis(thing)
    )
  )

This is in the very first example you see on the site. If it's a mistake, that's not encouraging. If this is actually how the language works, that's even less encouraging -- the syntax highlighter doesn't even get it right!

by semilin

For example, a typical web service I work on:

    - uses JSON APIs
    - it's fully stateless (uses external DBs/caches for persistence)
    - has the concepts of value objects, entities, architectural layers (app, domain, infra), ports/adapters etc.
    - only entities are proper rich objects, while most of the code is stateless services that operate on requests + entities + value objects
    - stateless services are composed (via interfaces) into a dependency tree (stored in the dependency container)

    module my_service

    layer app {
        service Adder {   // stateless service
            uses base int // a value-based dependency, injected in the container below

            method add(x int) int {
                return base + x
            }
        }

        service Doubler {
            uses a Adder  // delegates to another service

            method double(x int) int {
                return a.add(x) + a.add(x)
            }
        }
    }

    container {       // dependency container construction with injections
        A = Adder { base: 10 }
        D = Doubler { a: A }
    }

    // automatically generates a web server that exposes a JSON API with method "double" and accepts the "n" argument
    endpoint double(n int) int {
        return D.double(n)
    }

What do you think? Does it make sense? It basically moves something usually implemented by a framework into the language, but that's the entire point: a language optimized for writing compact, architecturally safe stateless services in a few lines of code. For example, since we know a request's memory is bound to that request (no global state), we can have very optimized memory management without a full GC => improved latency. Or for example, we can have compile-time checks for things like dependency direction validation (i.e. the domain layer cannot reference the infrastructure layer) to keep the architecture clean, etc.

by kgeist

Looks somewhat Python-like but modernised (great!) - is it indentation sensitive?

by anentropic