wisdom VS Alpine.js

If you want to output to a browser here is the guide to achieve the best possible performance according to the numbers:

https://github.com/prettydiff/wisdom/blob/master/performance...

Warning: every time I post this people claim to want superior performance but then whine when they realize they have to actually write code (as opposed to letting NPM or React or jQuery do 99% of everything).

This was attempt to research the fastest possible approach to a JavaScript GUI in the browser.

https://github.com/prettydiff/wisdom/blob/master/performance...

The techniques mentioned are stupid fast to the fewest milliseconds, but most JavaScript developers find this incredibly unpopular.

Measure everything and be extremely critical. Be ready to challenge common and popular held assumptions.

Here is something I wrote about extreme performance in JavaScript that is discarded by most programmers because most people that program JavaScript professionally cannot really program.

https://github.com/prettydiff/wisdom/blob/master/performance...

For simple state management here is what I do: https://github.com/prettydiff/wisdom/blob/master/state_manag...

Here is an application with an OS-like GUI making use of that concept: https://github.com/prettydiff/share-file-systems

The challenge is in determining who is about to become obsolete and that is not clear. For example OOP remains the most popular and requested programming paradigm even though it has gradually slid into functional obsolescence more than a decade ago[1].

Even still legacy code will remain in use and talent to maintain legacy systems will remain in demand. My university still teaches COBOL because there still exists demand for people to maintain these legacy applications even if new applications are no longer written in that language.

[1] https://github.com/prettydiff/wisdom/blob/master/Object_Orie...

That depends on how many changes it requires. If its just a matter of don't do these 3 things and your code suddenly becomes more predictable its like being slapped with a magic wand. Everybody wins. All you have to do to ensure 100% of your code compiles in a JIT is be predictable. Predictable code is, on its face, always less confusing.

> The performance benefits are likely to be minimal

This makes me cry, but not a cry of joy or ecstasy. People guessing about performance is perhaps the most frequent anti-pattern in all programming. Please read this document, you can skip to the end but it may not make much sense if you do. https://github.com/prettydiff/wisdom/blob/master/JavaScript_...

After talking about the biggest failures I have seen through my career in learning JavaScript I watched a YouTube video about an interview with a divorce attorney. It was interesting because the behaviors I heard expressed in that video exactly aligned with behaviors I see expressed in failures to learn after large commitments of time investment in programming. It inspired me to write this: https://github.com/prettydiff/wisdom/blob/master/JavaScript_...

The most important learning for me out of this is that people are predictable and how we commit is modeled by how perceptions of rewards are attained. It also inspired me to dive deeper into self learning about behavior and economics, because people do exceptionally irrational things to avoid perceived discomfort.

> just want to know what makes a good web framework.

Personal opinion. A framework is an architecture in a box so that you, the developer, do not have to make as many decisions. Normally when developers are asking such questions they are seeking easiness: https://github.com/prettydiff/wisdom/blob/master/Easiness.md

Software developers, especially DOM fearing front developers love using the word easy. It isn’t so much an infatuation but more like a fatal attraction obsession where obstruction means war on a very emotional level. Ironically, people are loathe to confront these feelings openly and thus cannot define the word easy with any kind of clear practical application.

So, I did the world a favor and wrote just such a definition: https://github.com/prettydiff/wisdom/blob/master/Easiness.md...

Depends on the definition of simplicity. People say they want simple, but then really want easy. The most easy is always somebody doing the work for you. I got tired of hearing people mention easy when really they probably mean some combination of fearful and/or lazy, so I chose to define easiness:

https://github.com/prettydiff/wisdom/blob/master/Easiness.md

If developers really wanted simplicity or to be done with work faster they would just learn the primitives of their environment: DOM, functions, and events. Most of the frameworks have APIs that are huge, so clearly simplicity isn't what's wanted.

Alpine.js for reactive frontend

✨ In recent months, I have been developing web projects using GOTTHA stack: Go + Templ + Tailwind CSS + htmx + Alpine.js. As soon as I'm ready to talk about all the subtleties and pitfalls, I'll post it on my social networks.

> But honestly, torn towards htmx but undecided.

We are in the middle of migrating from our monster react application into server rendered pages (with jinja2). The velocity at which we are able to ship and the reduction of complexity has been great so far.

Managing client side state for simple things like (is the dropdown open/closed), listening to keyboard events and such can be done with something like alpine-js [1] without all the baggage that something like react brings.

It appears this is already the trend with JS frameworks too - with server side rendering being the new norm.

[1] https://alpinejs.dev/

Sure, you can use any number of JS-avoidance libraries. I'm a fan of Turbo, and there's also htmx, Unpoly, Alpine, hyperscript, swup, barba.js, and probably others.

Direct DOM, but with a library. Specifically AlpineJS since it follows Vue closely in design practices allowing me to scale into a full web application if necessary (basically swapping to Vue takes minimal work). The Morph plugin is specifically what I like using.

If you want more details on the initial setup I encourage you to take a look at the Part I that covers more of the initial implementation. For this portion, I added Prisma as an ORM, a frontend style library called Tachyons, and AlpineJS to handle any client-side interactions. I did this to avoid needing to add a client-side bundler to the build and instead just rely on plain old module imports to compose the frontend. This is now the default for Rails and it is quite nice to not need any additional build tools for the client.

- [swallow-pywebview](https://github.com/rangwea/swallow-pywebview)： Base on [pywebview](https://pywebview.flowrl.com/) using Python，the frontend base on [alpinejs](https://alpinejs.dev/) and [tailwindcss](https://tailwindcss.com/)。

If you’ve followed our other tutorials, you might be familiar with Alpine.js. It’s a lightweight JavaScript library that allows you to add interactivity to your site without writing a single line of JavaScript. It’s incredibly easy to use, and we’ll show you how to make the animation trigger when the user scrolls to it.

The approach is not new, essentially a variation of Knockout, Alpine, and similar "JS-in-HTML" approaches.