posix_monad

With mergeMaps, you don't have to write out all of the properties.

MLs require a lot of ceremony modelling simple record types.

What we want to express here is an object with a map of properties (name to type):

    string Type map

For the OOP minded:

    Map<string, Type>

And also compose those:

    type Foo = { "_foo", int }

    type Bar = { "_bar", string }

    type FooBar = mergeMaps Foo Bar

But at compile-time, of course.

Have any languages achieved this? I know TypeScript can do some of these things, but it's clunky.

Building a language is too hard.

You need to create:

- Grammar, parser, compiler, interpreter (delete as appropriate)

- Editor plugins for nice syntax highlighting

- Language server

- Packages for common things

- Nice website (or no one will use it)

- etc...

So the pressure is always to shoe-horn a big existing language into you problem. Maybe you can build a nice library if your language has decent syntax (or little to no syntax). If you have an AST representation, you probably dump it to JSON etc.

I am curious if any projects are trying to make this easier.

Does MongoDB have serious market share compared to DynamoDB (and similar clones from Azure, GCP) at this point?

Yes, this is a reasonable approach, but how are certificates deployed and managed?

How do we deploy a list of certificates that a service should accept?

How do we do certificate rotation and revocation?

Vast majority do not have the disposable income to invest in stocks.

Nah, that was Postgres vector extensions

There is a value in living in a society that is culturally rich, not just GDP rich.

The last era where we had this kind of society, was probably the 70s and we are still recycling the cultural artefacts of that time.

That solution doesn't work for Meta. Who on earth would choose to opt-in?

Copilot (and so on) are simultaneously incredible and not nearly enough.

You cannot ask it to build a complex system and then use the output as-is. It's not enough to replace developer knowledge, but it also inhibits acquiring developer knowledge.

Not sure what you mean here - Microsoft are actively working on F# and the .NET Spark and Torch bindings.

I don't think the ML community has an appetite for learning a different language.

There are Microsoft-backed F# bindings for Spark and Torch, but no one seems interested. And this is despite a pretty compelling proposition of lightweight syntax, strong typing, script-ability and great performance.

The answer will probably be JavaScript.

Everyone already knows the language - all that's missing is operator overloading and a few key bindings.

Python's dominance is holding us back. We need a stack with a more principled approach to environments and native dependencies.

Rough news for the LSE, which was already trying to make that play.

Blank Street is eating their lunch

> build a extremely minimal kernel (i.e. ditch Linux entirely) and link your application against necessary bits of code

It would be nice, but this is really hard to do when modern software has so many layers of crud. Good luck getting say, a PyTorch app, to work doing this without some serious time investment.

You can publish across platforms with modern .NET

Cross compilation story in C# is very good actually.

> Tools like this do the deployment, they aren't generally deployed themselves.

It will have to be executed on many different developer machines (or even your own machine several years in the future) so a simple, reproducible build process, including fetching pip dependencies, is critical.

Python seems like a really poor choice for infrastructure.

- Python is not easy to build into portable binaries

- The package ecosystem is very hard to use in a reproducible way

- The language is not truly typed - types add massive value for infrastructure and scripts because they are less likely to be unit-tested

- The lack of a "let" or "var" keyword makes simple programming errors more likely (again, this code is less likely to be unit-tested)

Maybe I'm missing something? I don't know why I would want to introduce Python in this domain.

Why have do-notation if we can use fancy operators for everything?

I think this version would is less approachable for most developers.

IIUIR, Roc's syntax is more ergonomic than do-notation.

In Roc, you can put a "!" (bind) pretty much anywhere, whereas in do-notation it must be part of a binding.

    current_user <- fetch_user
    manager <- fetch_manager current_user

Compared to

    manager <- fetch_manager (!fetch_user)

Please correct me if I'm wrong!

The taxes paid on nicotene products more than offset the cost of the healthcare.

Very easy to put the a password into the wrong place when doing it manually.

TypeScript is not a good foundation to be building on. The language has very complex semantics and the only "spec" is the main implementation, which is also evolving.

LLMs and astro-turfing have ruined that approach. I honestly don't know where to get information from these days.