owlstuffing

Would be cool to hook this up as a manifold unit[1]. This way you could write code like:

Money ask = 2.1M USD;

What I don't see with the Java JSR is how exchange rate services are integrated (if at all?). In the best of worlds, as with manifold's units I could write.

Money deposit = 300 USD + 500 EUR;

Where internally the deposit automatically maintains the amounts separately and uses exchange rates only for spot display/calc, transfer, etc.

1. https://github.com/manifold-systems/manifold/tree/master/man...

The advantages of composition (or "true" delegation) over inheritance are well documented, but many languages remain poorly suited for it, particularly Java.

In the influential book "Effective Java" the author advocates favoring composition over inheritance, yet Java provides little support for it. One is left having to write or generate large portions of boilerplate code to achieve the most basic form of interface composition. More pragmatic support for the feature requires language/VM intervention, such as with true delegation and mix-in traits. This isn't to say the author's claims about inheritance and composition aren't well intentioned, however in practice it is difficult to make use of this advice when the language he champions, nearly a quarter century later, still does little to facilitate his position. The library mentioned here works toward a remedy[1].

1. https://github.com/manifold-systems/manifold/blob/master/man...

"access"

> I don't think I have any more bias than any other programmer.

Oh my. Quite the tell.

The manifold[1] compiler plugin for java offers a lot of features other languages like Kotlin provide, and innovates in some uniquely awesome ways like type-safe SQL, true delegation, etc.

1. https://github.com/manifold-systems/manifold

> I don't know why you are trying to make this a me vs them situation.

In terms of economic disparity it _is_ very much an us vs them situation.

Consider the optics over the last 20+ years. The middle class and their small businesses have been decimated while former VC funded companies hoover up their futures on Wall Street.

The level of risk involved starting an average small business is much closer to home compared with a startup seeking VC funding. The former can literally lose his shirt, the latter has to settle for a high six figure salary somewhere else.

Failing to see that limits the value of your comment significantly.

Correct answer

Not that economics is a credible science, but you’re conflating talking heads with economists. Talking heads exist to peddle the agenda of the elites who own them.

Sergeant Frank Tree: You shouldn't touch the ordnance at all. But more specifically, you should never pull this hand-operating lever to the rear.

Ward Douglas: Never.

Obey Consume Go to sleep Conform

They do indeed.

What will you do if your company becomes “successful”: is either acquired by a “big company” or becomes a “big company”? Particularly if you play a significant role in your company’s success? Maybe get a head start and learn about wood.

Try hyperscript. It’s like HyperTalk for the web. Pairs w htmx.

See https://hyperscript.org/

Ha! Nice.

Would be fun to use arbitrary events as time, like WW2. What time did you get up today? Germany invades Norway.

The data-to-code AI inference is inherently nondeterministic. How is that an improvement over performing deterministic coverage analysis? That sounds snarky, but it’s a sincere question.

It’s interesting that the relational model reflects interface inheritance as opposed to implementation inheritance. In my view it’s another indication that (true) delegation is generally a more suitable way to design software.

Yep, happy to see it, well deserved. Def a sleeper with tons of potential.

Comprehensive IntelliJ-level IDE tooling could bring Ada to the forefront where it belongs. Would be nice anyway.

There is zero science to back that up, natural selection ≠ evolution.

One reason it hasn’t gotten traction is due to a “herding cats” problem - the breadth of existing languages and SCMs in use is too big to manage. But mostly it’s the business model, who’s going to invest the vast amount of time for this when there is virtually nothing in it for them, it’s a giant onion. There’s little money in tooling, there’s far less in metatooling.

There’s also a bit of “squeaky wheel” resistance. Still a significant minority clinging to text editors as opposed to modern IDEs. But given the demographics here I imagine this segment will begin to shrink dramatically within a decade or so. Shrug.

> different languages have different grammars

Obviously. It should be understood that the idea is to have a standard AST API/format _per language_. As such it would be standard practice to provide this information as part of the parser/compiler library.

I understand your position that raw source is a simpler format. But in terms of professional IDEs is it simpler to throw out the parsed information and save only raw changes and force static tooling/IDEs to maintain separate caches and indexes of AST models? Not to mention the out of sync issues caused by this separation.

Is it simpler for source control managers like git to only understand text and make everyday changes such as rename refactors cascade across entire codebases and cause unnecessary, costly merge conflicts?

There are countless examples where AST-as-source _minimizes_ the complexities currently foisted on developers both directly and indirectly through tooling inefficiencies and other issues rooted in having multiple sources of truth.

> tbh the on-disk storage format is pretty irrelevant, it’s all just bits…

Nonsense. A completely attributed AST is the result of a full parse. The information in the AST is vastly richer than source.

> there is no universal tree type

Obviously. It should be understood that the idea is to have a standard AST API/format _per language_. As such it would be standard practice to provide this information as part of the parser/compiler library.

They’ll need a lotta pizza to eat their way out of their current situation.

Bit of a tangent, but if we commonly stored source in a standard, fully attributed AST instead of caveman text, caching/indexing and deterministic search would be a breeze. So would a million other useful applications such as every other IDE feature and source control.

As the decades go by it confounds me that we are still messing with plain text, and with virtually no resistance to it. Maybe it's to keep the tabs vs. spaces flame war alive. _shrug_

Yep. Pdn UI is most intuitive and is comfortably my 80/20 go-to tool.

Now THIS is news. Dogs are the best.

> I'm not 100% sold.

The vast majority of people that use it aren't, but that's a feature :)

Manifold isn't an all-or-nothing proposition. It's architecture is modularized so that you can select the parts you want à la carte as separate dependencies in your build.

> At the very least, I prefer not to have any surprises in my codebase

But manifold surprises are pleasant ones :) As with any library or framework, it's a design decision: does it provide enough productivity and opportunities to offset its presence in your project? It's not a panacea.

> just use Scala

Scala is a dying language, anyone boarding that ship is making a mistake. Anyhow, I prefer Java supplemented with powerful features Scala doesn't have, such as type-safe SQL.

> If you want type safe SQL in particular, you can pry JOOQ out of my cold dead hands.

Jooq isn't bad, but it's not SQL, it's Java trying to be SQL. Manifold lets you write type-safe, native _SQL_ of any complexity directly in your code.

> Been coding in Java since ~1997. Unsafe just doesn't come up in 99.999% of Java projects.

Your project may not use it directly, but there’s a pretty good chance one of your libraries does.

As a modern language Java is still quite feature deficient. But you can use compiler plugins like the manifold project[1] to level up.

1. https://github.com/manifold-systems/manifold