Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

Profile for fnando

Header for fnando: Orange is the new black (an orange background)
Display name
Nando Vieira
Username
@fnando@fnando.com

About fnando

Fields

Github
https://github.com/fnando
Blog
https://nandovieira.com
Blog (pt-BR)
https://nandovieira.com.br

Bio

Father, husband, software developer, 🇧🇷🇨🇦, he/him/ele, punk rocker, amateur guitar/bass player. Everything is fine.🔥

Stats

Joined
Posts
79
Followed by
151
Following
53

Recent posts

Yesterday I was creating something to replace Stimulus.js. Direct alternatives like alpine.js or htmx look kinda ugly with their DOM extensions.

I ended up creating something with jQuery (well, a stripped down version of jQuery that only includes the event handling part with min+gzip being 11kb).

Feels like Stimulus, but way smaller. The only downside (for now) is that you need to define events manually, but that doesn’t bother me, really. In fact, that was one of the things I didn’t really like about Stimulus: the disconnection between the controller and how events where defined in the DOM.

My solution handles things like connecting and disconnecting elements automatically, just like Stimulus.

This example weights only 12kb with min+gzip. I’m down! Tonight I’ll write the tests.

A POC to replace Stimulus.js with something similar. It uses a stripped down version of jQuery and it looks a lot like Stimulus itself. Here’s the sample code from the screenshot: // Initializing a new application // and connecting controller classes. const app = new Application(); app.register("counter", Counter); app.start(); // Defining a new controller class Counter extends Controller { private count = 0; connect() { this.count = 0; this.on("increment->click", this.increment); this.on("decrement->click", this.decrement); } increment() { this.count += 1; this.update(); } decrement() { this.count -= 1; this.update(); } update() { this.target("output").textContent = this.count.toString(); } } // The HTML 0 Increment Decrement A POC to replace Stimulus.js with something similar. It uses a stripped down version of jQuery and it looks a lot like Stimulus itself. Here’s the sample code from the screenshot: // Initializing a new application // and connecting controller classes. const app = new Application(); app.register("counter", Counter); app.start(); // Defining a new controller class Counter extends Controller { private count = 0; connect() { this.count = 0; this.on("increment->click", this.increment); this.on("decrement->click", this.decrement); } increment() { this.count += 1; this.update(); } decrement() { this.count -= 1; this.update(); } update() { this.target("output").textContent = this.count.toString(); } } // The HTML 0 Increment Decrement
Open thread at this post

Yesterday I started writing a “getting started” one-pager for my web framework with a sample to-do app and I didn’t like the `expose` approach, honestly. I think I’m going to do what Rails does, but with a twist: instance variables defined in the controller will be propagated to the view, but not partials.

I never allowed me to access instance variables from partials anyway, so it makes sense to me.

Open thread at this post

It doesn't matter how shitty the Rails leadership is (aka DHH), people will keep using Rails forever, even if you don't agree with anything political or where the project is going.

There's a whole business ecosystem around it, like consulting companies that specialized in Rails, thousands of companies running Rails as the product driver, so no other framework will ever dethrone it.

Unless there's a community fork that keeps backward compatibility while developing features for the future. And there's still a big chance that people won't migrate to the fork. The best chance we had was right before Merb’s merge. And DHH knew it.

All other frameworks, existing or new ones, don't have a chance and will always be niche. Most languages suffer from the "one framework to rule them all" syndrome, but it kinda sucks that we, the Ruby community, ended up with DHH.

Open thread at this post

I updated my minitest-utils project to include a test runner. I couldn’t use `m` because it doesn’t not detect the `test(desc, &block)` syntax, so I’ve been using mostly my reporter with Rake. It worked for the most part, but it had that `rake TEST=file_test.rb TESTOPTS="--name=test_some_test"` syntax, which is not great.

Now I can just run `mt file_test.rb:8`, with some other niceties like marking tests as slow, showing the slowest tests, and more!

A feature that I want to add is watching for changes and run only the failing tests.

https://github.com/fnando/minitest-utils/

Detect Slow Tests: By default, tests that take more than 100ms will be marked as slow, and you’ll see a list of the 100 slowest tests after your tests pass. Detect Slow Tests: By default, tests that take more than 100ms will be marked as slow, and you’ll see a list of the 100 slowest tests after your tests pass.
Replay Command: when a test fails, you can run that specific failing test by running the provided command, which uses the file:line syntax. Replay Command: when a test fails, you can run that specific failing test by running the provided command, which uses the file:line syntax.
Slow Tests: Mark tests as slow, and only run them by passing `—slow` or setting a MT_RUN_SLOW_TESTS environment variable. Slow Tests: Mark tests as slow, and only run them by passing `—slow` or setting a MT_RUN_SLOW_TESTS environment variable.
Open thread at this post

The mini framework I’m creating is _very_ similar to Rails in the way you write code. That’s because I like writing Rails code, and I wouldn’t like to deviate too much from it. The biggest difference, I think, it’s that everything is scoped by a module, like it or not. Controller? You define it like `Controllers::Pages < Zee::Controller`. Same thing for models, mailers, and helpers.

It’s never going to be a full replacement for Rails (otherwise forking would make more sense), but it brings a lot of the nice things I like about it, like helpers, partials (including collection rendering), a similar way of defining routes, flash messages, code reloading in development, form builders, mailers, and a small subset of Rails’ random utils.

For the frontend, it’s super simple: `zee assets` just calls two binaries (`bin/styles` and `bin/scripts`) and assumes that everything living under `public/assets` must be added to the manifest file. You’re free to use whatever you want, without any assumptions on the stack.

I think I’m pretty much ready to write a real app with it, so I can discover the rough edges. Let’s see how it goes!

Open thread at this post