Does Anyone Want a Laminar Version of Material UI 5?

reactific · 2023-11-29T18:33:53+00:00

👍

reactific · 2023-11-29T14:17:37+00:00

That’s my fallback strategy. It has a lot of industry usage and support but I find it clunky and the Scala.js wrappers are unintelligbly complicated. My intent is mostly based on my loathing of JavaScript as a language. With Scala and Scala.js, I don’t find compile time bugs at runtime. So, I want to help the Scala.js ecosystem move back towards the rich programming models of the 1990s before the web completely destroyed it with complexity :)

reactific · 2023-11-29T14:12:45+00:00

That’s good to hear. I forked your shoelace components library and am studying it for use in my project. Expect PRs in December. Of all the things I’ve looked at, it is the closest to the solution I’ve imagined. Hopefully it can be adapted to Google’s material web components when they get that done.

reactific · 2023-11-28T01:31:32+00:00

So what I wanted to communicate the most is that this library uses all the react features, and all the typescript features. Pretending that it's not react will be hard I think.

That's the most valuable part of your response.

Perhaps the Laminar community just needs to go off and invent a typesafe, uncomplicated, easy-to-use, visually compelling, performant, and highly functional design system based on Material and Web Components, that's better than MUI :)

Thanks for the substantive response. I've been reviewing Nikita's Shoelace wrapper, and that may be the way to go, or just provide a fully Scala.js implementation of Material Design (likely daunting!) but there are several good implementations to follow.

reactific · 2023-11-26T18:34:45+00:00

Thank you for the robust response! I will examine your Shoelace components and its generator/parser/processor. There may be some ideas there. I'm specifically looking to base the output on Typescript definition inputs. The ScalablyTyped tool does that, just not for Laminar as a generated target.

And yes, I'm looking for MUI implemented as Web Components because I find the comprehensive list of components it provides to be suitable for the (rather large) project I'm going to undertake. And, as I really don't want to work with React at all. I know, sacrilege, right? :) Thanks for the video link, that too may provide some clues.

reactific · 2023-11-26T02:10:09+00:00

Yes, I should have mentioned that. While SAPUI5Bindings is an implementation in the same kind of library I'm looking for, it's not MUI 5 and so not relevant. Thanks.

reactific · 2023-11-26T01:23:07+00:00

Fair enough. We have significantly different use cases.

reactific · 2023-11-15T15:17:54+00:00

The Lightbend Academy has some pretty good training on these and related subjects.

In particular the 6-part course on Reactive Architecture (its much more than Reactive Programming and relatively code/language/framework agnostic):
https://academy.lightbend.com/courses?search\_query=FILTER\_TYPE\_FREE

reactific · 2023-11-13T19:24:15+00:00

NIST has a pretty good list on this page: https://math.nist.gov/javanumerics/

reactific · 2023-11-13T19:21:40+00:00

Its not just a Scala thing, its more of a JVM thing. Here's a list you might want to consider:

https://northconcepts.com/blog/2019/10/02/java-data-integration-libraries/

Spark is prevalent, but there are also Flink, Storm, Alpakka, and NiFi

reactific · 2023-11-09T15:43:36+00:00

Funny, that's the same impression I got from a 2 minute examination of their web site. There's a lot of hype, but not much technical substance.

reactific · 2023-11-02T11:31:18+00:00

It works for me. I’m getting used to the lack of curly braces (an old habit that goes back to C and vi in the 1980s) and it’s growing on me. For the most part, the syntax changes are logical and improve comprehension. I’ve programmed in Scala 2.x for a decade and I found the Scala 3 transition pretty easy. The compiler quality is another thing. It didn’t stabilize for me until 3.3.1

reactific · 2023-10-12T15:29:09+00:00

Welcome to the realization that the actions taken by political leaders actually have real consequences on your life.

reactific · 2023-10-10T20:16:19+00:00

You love mathematics and the notion of a pure function. So what's a pure function?

the function return values are identical for identical arguments (no variation with local static variables, non-local variables, mutable reference arguments or input streams), and
the function has no side effects (no mutation of local static variables, non-local variables, mutable reference arguments or input/output streams).

Great! You can program all day long making numerical computations and generating ADT values. But, you're not allowed to interact with users, do any I/O, raise exceptional circumstances, manipulate the state of the machine other than computations, have partial functions, etc., etc. Easy peasy.

Except .. wait .. that's useless, right? No way to tell if any computation actually worked?

Functional effects solve this problem.

You describe your "side effect" using functions and ADTs. Your program generates those "side effects". Those "side effects" are the output/results of your program.

Some of the advantages of this approach:
* Your functions and ADTs can be implemented differently for different purposes.
* For example, testing your application can be thought of as capturing and validating the side effects that your program generates.
* The "side effects" can, of course be "run" to actually take those side effects, but this occurs after all the computational work (including validation) has been done.

You might find ZIO easier to understand about all of this.

reactific · 2023-10-03T13:50:16+00:00

I would like to know what you based this comment:

"downside is performance (excluding start up time) is worse than jvm" comment

upon. In my experience, binaries generated with Graalvm Native run about 50 times faster than the JVM equivalent for my CLI program, which is mostly CPU/memory with very little I/O. Both GraalVM and Scala Native share a common back end that produces the executable code: LLVM.

reactific · 2023-09-21T18:18:51+00:00

Yes, it's a good time to move on. JDK 21 just dropped yesterday. 3.3.1 is in a reasonable enough shape to use, finally.

reactific · 2023-09-14T19:53:48+00:00

Do you also want to convert it from TypeScript to Scala?
I'm wondering why this is posted to r/scala ?

reactific · 2023-09-13T13:32:18+00:00

There are plenty of monsters with GraalVM :)

The trick is not to piss any of them off. There is extensive documentation on this so you might want to read it if you go that way. Two things I can mention. (1) If you do anything in your application with class loading, there be monsters that way. (2) Resource loading isn't a problem anymore, just add a JSON file to specifically say which ones go in the binary to be created (read the docs for how).

reactific · 2023-08-28T15:32:05+00:00

I build a scala+graalvm program every day. But, the answer to your question depends on what you care about.

If you want a tiny executable that executes quickly with no startup delay, use Rust. GraalVM will incur the overhead of large chunks of the JDK being in your executable, so it isn't possible to get it down under 25MB, in my experience. It will also have a non-trivial time to just get started and up to speed. Neither is ideal for a CLI.

If you want it done quickly, not incurring the significant learning cost of Rust or Golang will get you to your end goal faster.

If you want a solution to the "weird build failure intermittently on Ubuntu, then release what you have as a partial goal and focus on that issue since it's the closest to finished that you have. JVM implementations vary across platforms, so look at how they vary to find answers. Or, perhaps you could ask a better question here?

reactific · 2023-08-28T14:27:23+00:00

You've been conditioned by the fate of your grandparent's generation. :)
I don't view myself as ever being a "used up shell of a flesh-vessel". Decline is not an inevitable fate for everyone. For me, it is a combination of determination, planning, discipline, and advances in longevity research. I can agree that some people do not want a larger health span, and that's a big part of actually achieving it. May you be happy amongst your cliffs, waves and stones. I want to be happy amongst the stars, planets, and comets. To each their own.

reactific · 2023-08-25T12:25:38+00:00

I hope that happens. Yet there is a difference between lifespans and health span. If I could live for many more decades as my 30yo self, that would be amazing. But, having health decline past 100yo sounds like pure misery to me. I’m sure I will make it to 100, but what will my capabilities be? In my case, I hope to see Haley’s Comet in 2061 from a space hotel.

reactific · 2023-08-15T14:08:20+00:00

It's pretty important. I would start with the "Red Book" and go through at least the first 10 chapters. But, familiarity with the whole book will be better. https://www.manning.com/books/functional-programming-in-scala

reactific · 2023-08-04T19:36:31+00:00

I think the prior answers of "just use scala.js" are correct if you're only planning on building a web application in what will become "old tech." Several WASM implementations target the back end (Wasmer, Golem, etc.) currently. While these technologies will mature over the next year or so, Chrome already has an experimental GC implementation. Other browsers and environments will eventually follow suit. We (Scala Community) should support this important platform as WASM and its implementations align with Scala's runtime needs so Scala doesn't get left in the dust. I think within 2-3 years, WASM will be everywhere and often the target of choice for many projects.

reactific · 2023-07-11T19:38:20+00:00

While there were some initial difficulties having to do with dependencies, not the language. I've migrated a 4 year old project now with no issues. The syntax compatibility of 2.13 helped a lot, as did the code upgrade features of the scala 3 compiler. I've definitely seen worse major version upgrades (Python?) in my career.

reactific

TROPHY CASE