TechPulseTechPulse
Back to News
Advertisement
Advertisement

⚡ Community Insights

Discussion Sentiment

88% Positive

Analyzed from 643 words in the discussion.

Trending Topics

#ctx#count#mador#write#read#proxies#without#great#dependency#where

Discussion (19 Comments)Read Original on HackerNews

moostee•about 3 hours ago
Proposed variant optimised for human readaiblity...

```js import mador from "mador"; const [read, write] = mador({ count: 1 }); read(".counter", ctx => ctx.el.textContent = ctx.count); write(".increment", "click", ctx => ctx.count++); write(ctx => ctx.count = 0); ```

## Read

Dependencies are detected automatically when the read function is run during initiation.

```js read(".counter", ctx => ctx.el.textContent = `Count: ${ctx.count}`); ```

## Write

Immediate:

```js write(ctx => ctx.count++); ```

Event-triggered:

```js write(".increment", "click", ctx => ctx.count++); ```

Event writes expose `ctx.el` and `ctx.event`.

bosmarcel•about 2 hours ago
O yes, thanks, appreciate it! I'm tired now, but i will find the time tomorrow to make it more readable!
afavour•about 1 hour ago
I’m curious to know what performance looks like. In the recesses of my memory is the belief that proxies are not good for performance but I have no idea if that’s well founded (or maybe once was but isn’t any more).

It’s a very smart idea though, I like it.

codedokode•31 minutes ago
It depends on count of variables and dependencies. The much worse problem with proxies is that they can be confused with raw values, for example, you can add a proxy into a Set, and then check for existence of a raw value. Or confuse raw value and proxy in dictionary's keys.
abosalehworld•about 1 hour ago
I love the minimalist approach here. Using Proxies for state management without the heavy overhead of large frameworks is really elegant. Keeping it under 80 lines is impressive. Great work!
bedroom_jabroni•about 2 hours ago
There are many standalone plug-n-play implementations of the signal primitive in JS. To name a few: preact/signals, vue reactivity, etc, there's even a TC39 proposal for a lang feature. Is this meant to stand out by doing things differently or reinvent them?
bosmarcel•about 2 hours ago
Honestly, mostly for the fun of building it and seeing how small and simple I could make it. While big solutions like Preact or Vue are great, sometimes you just want a tiny zero-dependency script without the overhead. And it turned out to be quite nice as I may say so
bedroom_jabroni•about 2 hours ago
preact/signals-core has 0 dependencies, your project could also benefit from mentioning what primitive is being implemented for the reader's information. The size difference is negligible. The readme creates a false dilemma where there's either Mador or "having to use a framework" but it hasn't been the case for ages - as I mentioned above the major frameworks have decoupled versions of their reactivity available. This makes the other reply where "the frontend community deserves tools like this" sound weird because it ignores the great tools that have been available for a while.

Good learning experience but a very weird presentation.

bosmarcel•about 2 hours ago
That's a fair distinction, but I think they solve different problems. Signals are great, but they usually require managing primitives individually and don't map directly to deep, nested JS objects the same way. Mador is specifically about dropping in a plain, nested object and working with it like normal JS without .value "boilerplate". Appreciate the feedback on the README phrasing though—I'll tweak it so it doesn't sound like a false dilemma!
afavour•about 1 hour ago
First time I’ve seen Preact described as a “big solution”!
PoignardAzur•about 3 hours ago
Are reactive updates based on deep equality or reference equality?
bosmarcel•about 2 hours ago
It is based on ref. equality, so assignment through '=' will trigger an "effect".
DylanMerigaud•about 3 hours ago
Clean launch, good luck!
bosmarcel•about 3 hours ago
Thanx a lot!
ahmedhossamdev•about 3 hours ago
Great work!
bosmarcel•about 3 hours ago
Thanks, I really appreciate it! Hope others will feel the same. The frontend community needs and deserves simple tools:)
antonvs•about 3 hours ago
This makes me think of a version of that comic where in the last pane, you get thrown out the window for suggesting such a sensible thing.
bosmarcel•about 2 hours ago
Hahaha! Exactly
bosmarcel•about 3 hours ago
Hey HN! I wanted to see how far you can push modern JavaScript Proxies without all the heavy overhead of a traditional framework. The result is Mador: a tiny ~80-line reactive state tuple ([r, w]) that lets you make any DOM element reactive using a simple CSS selector, automated dependency tracking, and batched microtasks. No build steps required—just drop it in. I built this over the weekend just to experiment with clean, zero-dependency reactivity. Would love to hear your thoughts or see where you'd run into limits with something like this!
hamburglar•about 2 hours ago
> Hey HN! I wanted to see how far you can push modern JavaScript Proxies without all the heavy overhead of a traditional framework. The result is Mador: a tiny ~80-line reactive state tuple ([r, w]) that lets you make any DOM element reactive using a simple CSS selector, automated dependency tracking, and batched microtasks. No build steps required—just drop it in. I built this over the weekend just to experiment with clean, zero-dependency reactivity. Would love to hear your thoughts or see where you'd run into limits with something like this!

Unsure why this comment from the author was flagged/dead but it certainly doesn’t seem to run afoul of HN guidelines.