fjb
Mithril.js
fjb | Mithril.js | |
---|---|---|
6 | 50 | |
106 | 13,924 | |
- | 0.7% | |
5.0 | 3.4 | |
over 2 years ago | 25 days ago | |
C | JavaScript | |
GNU General Public License v3.0 only | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
fjb
-
Rome will be written in Rust
esbuild is the current darling leading the pack, but there are also various other projects in the space (swc[0] is written in Rust, fjb[1] is written in C, bun[2] is written in zig, leveraging JavascriptCore's engine).
The most significant performance-oriented effort in this space still leveraging JS that I know of is kataw[3], and while that's quite fast compared to babel, it's still within an order of magnitude from babel. Kataw itself is a CST-based implementation that was created to outperform seafox (a AST-based parser by the same developer).
Babel gained popularity due to the crazy amount of churn in grammar over the past few years, but more and more I think the dust is settling, and flexibility is no longer the name of the game, making an AST-based implementation less appealing. The Rome team must be feeling the heat if the data structure design choices are being informed by performance. I highly doubt someone will be able to compete in performance using a JS implementation in today's landscape.
[0] https://github.com/swc-project/swc
[1] https://github.com/sebbekarlsson/fjb
[2] https://bun.sh/
[3] https://github.com/kataw/kataw
-
From a Single Repo, to Multi-Repos, to Monorepo, to Multi-Monorepo
Nice write-up. I have explored different repo strategies quite a bit myself in the course of a few efforts that I've been involved with. On one, we originally had a monolythic framework and everything the article said about cons is pretty spot on. However, I'll qualify by saying that I think the problems come less because of the nature of monolyths in general and more because of lack of experience with modular design.
We then wrote a new framework using a monorepo approach, with separate packages using Lerna. The problem here was tooling. Dependent builds were not supported and I've had to delete node_modules more times than I'd ever cared to count. The article talks about some github specific problems (namely, the issues list being a hodge-podge of every disparate package). We tried zenhub, it works ok, but it's a hack and it kinda shows. I've seen other projects organize things via tags. Ultimately it comes down to what the team is willing to put up with.
We eventually broke the monorepo out into multi-repos, and while that solved the problem of managing issues, now the problem was that publishing packages + cross-package dependencies meant that development was slower (especially with code reviews, blocking CI tests, etc).
Back to a monorepo using Rush.js (and later Bazel). Rush had similar limitations as Lerna (in particular, no support for dependent tests) and we ditched it soon afterwards. Bazel has a lot of features, but it takes some investment to get the most out of it. I wrote a tool to wrap over it[0] and setup things to meet our requirements.
We tried the "multi-monorepo" approach at one point (really, this is just git submodules), and didn't get very good results. The commands that you need to run are draconian and having to remember to sync things manually all the time is prone to errors. What's worse is that since you're dealing with physically separate repos, you're back to not having good ways to do atomic integration tests across package boundaries. To be fair, I've seen projects use the submodules approach[1] and it could work depending on how stable your APIs are, but for corporate requirements, where things are always in flux, it didn't work out well.
Which brings me to another effort I was involved with more recently: moving all our multi-repo services into a monorepo. The main rationale here is somewhat related to another reason submodules don't really fly: there's a ton of packages being, a lot of stakeholders with various degrees of commit frequency, and reconciling security updates with version drift is a b*tch.
For this effort we also invested into using Bazel. One of the strengths of this tool is how you can specify dependent tasks, for example "if I touch X file, only run the tests that are relevant". This is a big deal, because at 600+ packages, a full CI run consumes dozens of hours worth of compute time. The problem with monorepos comes largely from the sheer scale: bumping something to the next major version requires codemods, and there's always someone doing some crazy thing you never anticipated.
With that said, monorepos are not a panacea. A project from a sibling team is a components library and it uses a single repo approach. This means a single version to manage for the entire set of components. You may object that things are getting bumped even when they don't need to, but it turns out this is actually very well received by consumers, because it's far easier to upgrade than having to figure out the changelog of dozens of separate packages.
I used a single repo monolyth-but-actually-modular setup for my OSS project[2] and that has worked well for me, for similar reasons: people appreciate curation, and since we want to avoid willy-nilly breaking changes, a single all-emcompassing version scheme encourages development to work towards stability rather than features-for-features-sake.
My takeaway is that multi-repos cause a lot of headaches both for framework authorship and for service development, that single repos can be a great poor-mans choice for framework authors, and monorepos - with the appropriate amount of investment in tooling - have good multiplicative potential for complex project clusters. YMMV.
[0] https://github.com/uber-web/jazelle
[1] https://github.com/sebbekarlsson/fjb/tree/master/external
[2] https://mithril.js.org/
-
JavaScript Minification Benchmarks
I also made some benchmarks, including my own bundler:
https://github.com/sebbekarlsson/fjb/benchmarks.md
-
I'm writing a JS bundler in C
I've added some benchmarks: https://github.com/sebbekarlsson/fjb/blob/master/benchmarks.md
- Show HN: JavaScript Bundler Written in C
Mithril.js
-
Ask HN: I can no longer like React, do you?
I don’t enjoy React much, but (as I’ve commented before) I do love Mithril (https://mithril.js.org). Immediate-mode UI via a vDOM, like React, but small, simple, and with none of the reactivity complications. I’d never go back to building apps with pure JS.
-
Mithril.js: A Modern Framework for JavaScript
You can find more information about Mithril.js on its official website.
-
Ludic: New framework for Python with seamless Htmx support
The idea of nested function calls to build HTML is not new. Back in the hey-day of JS frameworks, this was a common vdom pattern. I kinda miss [MithrilJS](https://mithril.js.org/#dom-elements)
-
No CMS? Writing Our Blog in React
I have mixed feelings about React. I like it better than jQuery, and better than other JS frameworks I’ve used.
But I much prefer Mithril (https://mithril.js.org/), which offers the same immediate-mode advantages (https://news.ycombinator.com/item?id=19746235) but without the crazy complex dependency-tracking reactivity.
I rather liked this comment on React: https://news.ycombinator.com/item?id=38640051
-
VueJS turns 10 years old
Vue with Vite (the builder/runner) is a stable, open source option. It is really a lightweight start where you're mostly writing HTML with interpolated data, and Vue is updating values correctly and performantly. Just build your reactive HTML app in one file and break into separate components as you're feeling the spirit. https://vuejs.org/guide/quick-start
Mithril if you just want to drop in want a tiny, complete reactive library that doesn't require a build step--this one is most like what you might end up creating in a large jQuery app. You can understand everything from the homepage. https://mithril.js.org/
HTMX if you really like HTML conventions. This doesn't feel jQuery-like and depends on your approach to your server app. https://htmx.org/
- VanJS: A 0.9KB JavaScript UI framework
-
HTMX for pages with heavy user interactivity
React is still has gratuitous complexity. If you need some React like, take a look at mithril which is simpler and much smaller.
-
Lodash just declared issue bankruptcy and closed every issue and open PR
The submitter creating multiple var -> let PRs (one PR per file), was also doing this in other projects, and would've broken some of their users.
https://github.com/MithrilJS/mithril.js/pull/2880#pullreques...
And he created multiple PRs there too. And didn't follow their workflow...
- Produce HTML from S-Expressions
- Vanjs
What are some alternatives?
swc - Rust-based platform for the Web
Alpine.js - A rugged, minimal framework for composing JavaScript behavior in your markup.
event-dispatcher - Provides tools that allow your application components to communicate with each other by dispatching events and listening to them
Preact - ⚛️ Fast 3kB React alternative with the same modern API. Components & Virtual DOM.
minification-benchmarks - 🏃♂️🏃♀️🏃 JS minification benchmarks: babel-minify, esbuild, terser, uglify-js, swc, google closure compiler, tdewolff/minify
riot - Simple and elegant component-based UI library
node-sodium - Port of the lib sodium encryption library to Node.js
inferno - :fire: An extremely fast, React-like JavaScript library for building modern user interfaces
nexe - 🎉 create a single executable out of your node.js apps
Vue.js - This is the repo for Vue 2. For Vue 3, go to https://github.com/vuejs/core
rombundler - A tiny libretro frontend to release homebrews as executables
Aurelia 1 - The Aurelia 1 framework entry point, bringing together all the required sub-modules of Aurelia.