ljloisnflwef

It's the boom/bust cycle we've experienced with Ruby on Rails, Node.js, Scala, MongoDB.

The initial adopter/FOMO/hype phase is over.

Gaming was over / Early Sell signals:

* Valve going full cosmetics

* Half Life 3 never being released

* Biannual Call of Duty titles

* The end of community hosted servers & server browsers

* The rise of Early Access & DLCs

* John Carmack leaving id software

Welcome to Kubernetes!

I don't know what went wrong but the ecosystem prefers software presented as a black box and shrouded with mystery.

If you contrast this with Envoy, it has stellar documentation -- Envoy wants you to know how it works!

Envoy is used and abused by Istio (k8s wrapper) which has terrible documentation, history of horrific upgrade/update story, (& software quality).

The majority of my life has been out of my hands or control.

So it doesn't feel like "my life", rather on a ride I can't get off or interface with.

For me to find value in something, it should grant at minimal autonomy.

In this example, it's why Java added sealed interfaces, otherwise left with ∞ - 1 possibilities.

  if (!(node instanceof DomNode.Element)) {
    return new RenderNode.Noop(/* ... */);
  }
  Layout layout = node.layout;
  return new RenderNode.Styled(layout, /* ... */);

Yes and no.

Consider predicate types, or first-class null safety through unions.

If statements introduce propositions, which type systems could take advantage.

example:

  let idx = randomInt();
  if (0 <= idx && idx < arr.length) { // proposition introduced
    // idx now has type: int where 0 <= idx && idx < arr.length
    // irrefutable proof of safe indexing by type propositions
    let value = arr[idx];
  }

We don't hold language authors accountable, and accept mediocrity.

I encourage you to explore why generics exist in the first place by exploring topics such as Parametric Polymorphism, Higher Kinded Types, & Higher Kinded Polymorphism.

The truth will set you free.

There's genuinely good things that came from FP that creeped into popular languages:

* Algebraic data types

* Pattern matching (with exhaustiveness)

* Lambdas / Closures

* Type inference

Other options:

* Use linear / affine / session types / move semantics

* Describe an interface, then weave side effects through it, such as the State Monad.

* Use lenses