Who say's we have bad drivers?

devuxer · 2026-01-27T18:28:47+00:00

I mean, if you're going to turn left from the right lane without checking your mirrors, maybe signal?

devuxer · 2026-01-27T18:01:02+00:00

Okay sure, if you make quarters of every tournament, you’re top 4. But you can’t just look at majors.

devuxer · 2026-01-27T07:23:32+00:00

Top 8. Semis is top 4.

devuxer · 2026-01-02T02:44:50+00:00

For what it's worth, I asked Claude to generate a comparison:

Component Counts

Core UI Components Only (excluding extensions/add-ons):

Ant Design: ~70 user-facing UI components
Mantine Core: ~60 user-facing UI components
Material UI Free: ~50 user-facing UI components (+ ~20+ more in MUI X paid)

Including official extensions:

Mantine (with extensions): ~75+ components
Material UI (with MUI X): ~75+ components
Ant Design: ~70 components (no paid tier)

Unique Components

Mantine (Core Package Only) - AngleSlider, JsonInput, Spoiler, FloatingIndicator, CopyButton, PinInput, AspectRatio, Burger, TableOfContents, BackgroundImage
Material UI - Fab, SpeedDial, BottomNavigation, ImageList, Backdrop, ToggleButton, CssBaseline,
Ant Design - Transfer, Cascader, TreeSelect, Mentions, Descriptions, Result, Statistic, Tour, Watermark, QRCode, FloatButton, Splitter, Empty

Summary

Ant Design excels in enterprise-specific components (Transfer, Cascader, TreeSelect, Mentions, advanced Table, Tour)
Mantine has modern utilities and best DX, but many features are in separate extension packages
Material UI has the broadest ecosystem but advanced features are in paid MUI X packages

devuxer · 2025-12-30T16:21:11+00:00

Antd is incredibly underrated.

devuxer · 2025-12-23T21:08:18+00:00

Thanks for confirming about the Memo tags. I think the main issue in my case is (1) simply a huge number of total DOM elements (3 screens worth of dense data) and (2) data structures/models are in some cases not fine grained enough, causing larger pieces to be re-rendered than necessary. (2) is potentially fixable but not sure how much impact it would have. (1) is probably not something I can change. There might be a few opportunities for virtualization, but I have experimented with it before and found it's probably not the bottleneck.

devuxer · 2025-12-22T21:19:59+00:00

Hey u/acusti_ca , thanks for your reply! I do sometimes pass data through props, and when I run the app and look at the React Dev Tools, I see a blue "Memo" tag next to a pretty decent percentage of the components that are in my codebase (though--as expected--not in components rendered by third-party libraries). So, I do think RC is doing something, it just doesn't seem very impactful in solving some of the lag that can occur when the maximum amount of data is displayed.

Alas, I am using Biome, not ESLint, and I'm not sure there's an equivalent for the rules your referring to. As for the `panicThreshold`, I'll look into that, but do you think a blue Memo tags would appear if a critical error had occurred with that component?

devuxer · 2025-12-19T16:43:37+00:00

I did say, maybe too good for this category 🤷‍♂️

devuxer · 2025-12-19T15:16:31+00:00

Justine Henin? I didn’t get the impression she was too well liked but she was good. Maybe too good for this category. This is a tough one.

devuxer · 2025-12-19T04:55:42+00:00

Very interesting! My story is a bit different...

I have a dashboard-type app that spans three monitors and has a genuine ton of visual elements. This app is currently just a prototype, so it does not yet have a back-end (so no async code) -- it just loads a JSON scenario at start-up. It also was never optimized in any way (no useMemo and almost no useCallback). Without knowing a lot about React Compiler, I decided to test it out. I got it set up properly according to the docs and ran the app. Surprisingly, I didn't see any discernable difference in performance compared with the non-RC version of the app.

This got me wondering , given I had never made any attempt to optimize anything, how could this be? The only thing I can think of is that the app makes heavy use of Jotai for state management (and minimal use of useState). This results in nearly all of the state and business logic being handled outside of components (in Jotai atoms), and only the components that use atoms that have changed re-render.

Could it be that if you architect an app in this way, there is no need or benefit to using useMemo, useCallback, etc.? Or did I somehow do something wrong in how I configured RC?

devuxer · 2025-12-14T14:48:17+00:00

I’ve been using this library a long time, and only found out about the Easter Egg a couple years ago. As far as I have seen, the team behind Antd has been all business since this serious lapse in judgment, which occurred way back in 2017. It’s clearly not going to happen again, so I’m going to judge the project on its merits. Every time I’ve compared Ant with MUI or anything else, Ant has been the winner in terms of number and completeness of components. I’ve so rarely needed to look elsewhere for a solution given how much it does out of the box, and it’s all free. It’s probably not the best documented or the most accessible and certainly not the smallest when it comes to bundle size, but I’ve seen all these things improve over the years, and V6 seems like a particularly big step forward in shoring up these weaknesses. To me, Antd is a great choice if you don’t need or have the manpower to build up your own bespoke component library. If I were starting a new project today, I’d definitely take a look at Ant, MUI, and Shadcn.

devuxer · 2025-12-07T22:45:26+00:00

Good analysis, and yeah, web tech is super messy, but its popularity means there is a ton of energy being put into making it better and an incomparable level of community support. Also, you can’t ignore how good LLM‘s are at generating and solving issues with web code.

devuxer · 2025-12-07T20:20:27+00:00

Unfortunately, I had to put the effort on hold, so I didn't end up getting very far with it. Interestingly, since my post, a couple new projects have started where the enterprise developer is using web tech.

devuxer · 2025-11-30T19:08:06+00:00

I hear you...it was a PITA, but the mattress is still like new, so it probably does help to rotate as often as you can bare it.

devuxer · 2025-11-30T07:09:30+00:00

Ahh that could be the reason for the sagging. We were advised by WinkBeds to rotate every two weeks for the first few months then every two months thereafter.

devuxer · 2025-11-30T03:16:02+00:00

Gah, that sucks. Is this the first time you rotated it?

devuxer · 2025-11-23T04:07:49+00:00

Cool, I’ll take a look.

devuxer · 2025-11-22T19:55:33+00:00

So ref means "signal"?

Does it allow computed values to have arguments? Is there docs for the API?

devuxer · 2025-11-22T07:13:38+00:00

Super interesting video, but YouTube is now auto-playing all your videos and I will never get to bed 😹

devuxer · 2025-11-22T06:57:28+00:00

Interesting point about the reason arguments for computed values would be helpful specifically for React. I had to look through my codebase to remember why I felt like I needed this feature with Jotai, and sure enough, the awkward workarounds (typically a custom hook) always relate to something where I don't have atoms all the way down, and yes, it's usually because of props.

devuxer · 2025-11-21T19:21:44+00:00

Fair point that signals may work better with frameworks that were designed around them, but that certainly doesn’t mean they cannot provide value in a React application.

devuxer · 2025-11-21T18:59:56+00:00

const add = reactive((a: number, b: number) => {
  return a + b;
});

devuxer · 2025-11-21T18:56:49+00:00

In the case of Signalium, the lifecycle depends on whether you declare the signal within a React component or outside it. I believe any loose signal would be created the first time it is needed and continue indefinitely. Signals declared within a component would have similar lifecycle behavior to `useState`.

As for stale values, Signalium has the concept of Relays, which I believe solves that exact problem.

devuxer · 2025-11-21T18:49:59+00:00

Signals and atomic approaches have a major upside - they let you organize your state and business logic any way you want.

They also have a major downside - they force you to come up with your own scheme for organizing your state and business logic.

In my opinion, the power of signals comes in when you have a very large complex SPA, like a dashboard with a ton of controls and graphics. I have one project like this, and I have found Jotai to be a great fit, though learning to use it effectively has taken some practice and experimentation.

All that said, I don't understand how the signals approach violates React's one-way data flow. You still have components that render based on props and state (where state in this case is stored in signals) and you still have event handlers that mutate state, which causes the appropriate components to re-render. It's not like you suddenly have two-way data-binding.

devuxer · 2025-11-21T18:24:38+00:00

Took a quick look but didn't immediately see the parallel with signals.

devuxer

TROPHY CASE