greener_grass

Age of Empires II is very popular but doesn't have multiplayer support on Linux.

Technically maybe, I don't know. But in practice, your bash will use tools like this and break if they are different / missing on a future build host.

If using a programming language with locked-down package dependencies, then all you need is the compiler/interpreter and your script will work.

Does a game "run on Linux" when it has 100% feature parity? 90%? 80%? What are you willing to cut? Some performance? A few graphical effects? Multiplayer?

When you look at the details, Linux gaming is not as good as it might seem.

But I'm still gaming on Linux!

The tools you will call from your bash script differ in subtle ways between Linux, macOS, MinGW.

One good example is `uuidgen`

Bash is not a great cross-platform choice. Too many subtle differences.

The best way is a scripting language with locked-down dependency spec inside the script. Weirdly .NET is leading the way here.

If you are not willing to make this trade then how much of a priority was run-time performance, really?

Tutorial was pretty confusing to me. I formed "HIM" and it rejected it, no explanation why.

Project 2025 was strongly against active travel, yet increased car dependency is one of the main factors in poor health in the USA.

MonoGame is stable and still receiving updates.

I would strongly suggest that for quick code-first prototypes. The boiler-plate of "load a texture and render to screen" is quite minimal - you could perhaps make a small library for yourself?

It also has no opinions about how you structure your game data. This means you can represent things like a Flappy Bird clone as just a `Vector2`, rather than having to bash a graph of entities in the shape you want.

CodeWars has a nice Kata grading system that features many intermediate level problems.

> The real answer to all this is to use a provider that supports idempotency keys. Then when you can retry the action repeatedly without it actually happening again. My favorite article on this subject: https://brandur.org/idempotency-keys

Turtles all the way down?

Let's say you are the provider that must support idempotency keys? How should it be done?

Is the real Mark Shinwell on here?

https://github.com/mshinwell

Buck 1 used Python directly and it had lots of issues compared to Starlark.

There are. The rhetorical strategy is to argue that Brexit was a good idea, but it has not been implemented properly. Look for the phrases "Brexit means Brexit" and "proper Brexit".

How would you measure these?

- making associations

- generating original ideas

- more perceptive

...

"spatial awareness" I can see though

This is how Debezium works.

It is probably best to use that unless there is a strong reason against.

The EA / Rationalist / AI Safety crowd tend to think they can overcome these impulses

Smaller is better, of course, but I've never found the size of .NET binaries to be an issue.

What problems does this cause?

> dotnet requiring a CLR is not particularly well-suited for containerization

Why? I routinely put compiled .NET programs into containers.

It's also easy (easier than Rust even) to build on Mac targeting a Linux image.

I am talking about C# / F# context where the lists must have homogeneous types.

That TypeScript supports this is yet more complexity introduced to cover usages of an API not designed around types.

Here `a` and `b` can have different types:

    let! a = fetchA() and! b = fetchB()

Whereas `Promise.all` usually requires all promises to have the same type (returning a `List<T>` or even a `List<obj>`) .

See https://learn.microsoft.com/en-us/dotnet/fsharp/whats-new/fs...

What are the cross-stack gains of Python?

Running TypeScript on the server is a well trodden path. It can be pretty fast too. Python on the client, not so much.

This isn't true, because more is not always better.

C# has lots of anti-features that F# does not have.

Applicative Computation Expressions are a big deal (added in F# 5). Recent changes have been smaller in scope.

Unfortunately lots of the more advanced stuff seems to be blocked on C# team making a decision. They want a smooth interop story.

But F# remains a solid choice for general purpose programming. It's fast, stable and .NET is mainstream.

F# is a practical choice but the language features are quite far behind OCaml now.

{Ecosystem, Functors} - choose 1

For me the issue is ecosystem. The foundations are great but I need more useful and well supported packages.

For example, there is no OAuth2 client library for OCaml [1]

[1] https://ocaml.org/docs/is-ocaml-web-yet

That would be Elm :)

Shouldn't most application programmers in OCaml be reaching for EIO or some other well-tested abstraction?

Define functional?

Even Haskell is not functional in the strictest sense. It has unsafe IO. It can throw exceptions. Functions may not halt.

• Stategraph manages Terraform state, so correctness isn't optional

TypeScript has soundness issues that OCaml does not have

• Strongly-typed data structures catch field errors at compile time

TypeScript does have this, although the guarantees are in practice weaker since libraries may have incorrect type definitions

• Type-safe SQL queries prevent schema drift before deployment

There are TypeScript libraries that offer this, so fair point!

• Immutability by default eliminates race conditions

TypeScript is not immutable by default

• PPX generates correct JSON serialization automatically

TypeScript does not have an equivalent to PPX infrastructure AFAIK. If there is, it's definitely not as widely used within the ecosystem compared to PPX for OCaml.

Edit: Downvoters care to respond?