#solidjs

[mehbark]

yesterday's homestuck ama archive

[working-dad-2010]

Reactivity in SolidJS

[lizclipse]

genuinely, signals & control flow & the inject function have taken angular from being a "meh it has it's uses but it's not great" UI framework to one of my favs in the space. the way you structure components now is so unbelievably different to when i started with it back at like v6 it's like an entirely new framework and honestly it's really fun to use. i'm actually looking forward to new releases since it always opens the door to new and interesting ways of doing something that's easier than before, and i actually want to make UIs with it instead of pining for something else

[wenextlab]

Frontend Development: Skills & Tools You Need in 2025

Frontend development is more exciting—and complex—than ever in 2025. With new frameworks, faster build tools, and AI assistants entering the scene, the demand for skilled frontend devs is at an all-time high.

At its core, frontend development focuses on building the parts of a website or web app users directly interact with. This includes:

Layout and styling (HTML, CSS, Flexbox, Grid)

Logic and interactivity (JavaScript)

Frameworks (React, Vue, Svelte, SolidJS)

Optimization (Lighthouse, Core Web Vitals)

Responsive and mobile-first design

Today, a solid frontend developer should know:

React or Next.js for building SPAs or server-rendered pages

Tailwind CSS or CSS Modules for styling

TypeScript for better code safety and scalability

Vite or Turbopack for lightning-fast development builds

Headless CMS like Sanity or Strapi for dynamic content

Accessibility (WCAG standards) to ensure usability for all users

The lines between design and development are also fading. Tools like Figma to Code, AI design assistants, and component libraries make collaboration between devs and designers seamless.

AI is also making a big splash. Tools like ChatGPT, Copilot, and AI-powered component generators can help speed up prototyping, debugging, and even documentation.

To succeed in frontend development in 2025, you’ll need more than just technical skills. You should also master UX thinking, SEO basics, and performance optimization.

In short, frontend dev isn’t just about making things look good—it’s about building fast, accessible, and responsive experiences that users love.

[redneckdysguys]

100daysofcode #day001

The npm advantage

As a developer you need all the api's that are available so that you don't have to reinvent the wheel. There is no point in that, npm allows you to reuse code that someone has made into a lib-utility. I call it a lib utility because it's normally a full set of programming api that enables you to achieve a purpose by making you harness the source code that actually makes your life easy. Infact under the hood react itself is a lib-utility but it's seen as a framework altogether. Most JavaScript frameworks leverage the npm system or reusing code. Frameworks like react, svelte, angular, vue.js, solidJS and quik.

Building cross-platform Apps with Electron and React

Above are most frameworks that are mainstream, I did not include nextjs, nuxtjs and preact because are a subset of mainstream frameworks. React was made as a single page application to solve a problem of server roundtrips which had performance issues. In the same way Electron was developed so that web developers that sometimes get a one of desktop application project don't have to go learn another programming language.

Npm package managers

There used to be a package manager called npm which was the native package manager and its very good. Since everyone is on the mission to solve problem, there has been an introduction of yarn and pnpm which is the latest. Pnpm came out in 2022 and its awesome, I will not go into the improvements made in yarn and pnpm but I will say node package manager(npm) is the tooling you need to use to install all you npm into your projects. After you install NodeJS, the base tool you need to develop JavaScript, It has prebuilt api's that allows you to access the filesystem, scientific and arithmetic base and console tools. These modules will be added by default in any node project along with the ones you would like to use.

[vastperhaps]

SolidJS · Reactive Javascript Library

[lackhand]

My Server Side Rendering thoughts

I'm tech advising my friends' startup and it's interesting. Out of our discussions, I had a thought I wanted to get down in ink.

Client Side Rendering sucks for small teams but is nearly impossible to escape in Standard Technologies^1.

^1: Cunningham's Law: "the best way to get the right answer on the internet is not to ask a question; it's to post the wrong answer"

Backend development is basically fine

Say that you are writing an internal tool website. In his case it's a sales-y CMS-y thing; an integrated wizard & search tool. Obviously there's a few domains there (the Requirements server! The Catalog & search product! the produced Proposals!) and there's a sane UML chart about how the layers interact. Cool.

You've picked a language like ts/js/go/py/php/kotlin for your backends based on skill availability, libraries, etc. You're done, right?

But!

Frontend dev still requires a completely different approach

Developing the frontend for this kind of sucks. You've written a sane set of microservices in your favorite backend technology, yes, but when it comes time to knit them together, you probably need to switch technologies. You're going to pick React (or equivalently Svelte, Vue; Solidjs, etc), because you want a Single Page Application website.

At WebScale(tm), this makes sense: nothing scales or is available like the users' own browsers for the interactivity parts of your app. But if you're optimizing for the simplicity and team size, I'm not sure you want to bring a completely second technology into this game.

Liveview writes the frontend for you ASTERISK! FOOTNOTE! SEE CIT!

My friend's background includes the Elixir/Phoenix/Liveview stack^2.

Liveview uses a persistent websocket between the client and server. The client sends browser events to the server across the socket. The server uses a react-like events-and-caching-and-reevaluating model to determine changes to state as a result. The server uses session state to maintain its own mirror of the browser's DOM, and then streams the differences to the frontend, where the standard clientside javascript library applies them, and the cycle continues.

^2: 15 bits entropy remain

Chris McCord on how and why Liveview is, c. 2021.

Ok, so...? How does this help the solo dev?

At this phase, separation of concerns is overrated and you're probably not doing it right anyway.

You're a small-team multi-hat dev. You are building this app by the seat of your pants; you are not sure the UI you're building is the right UI yet.

So if you do normal React stuff, the flow of data is something like:

... → [Raw Database Schema] → [Internal Business Object in e.g. python] → [Display-oriented GET API in python on server] → [Serialize JSON] → [React render in typescript on browser] → [React produces final DOM changes on browser]

Those "display oriented API"/Serialize/"react HTML" lines are really suspicious at this point. Even though you've modeled your business objects correctly, every change to the interaction model requires synchronized FE and BE changes.

This is more than a protocol problem: something like protobufs or tRPC or whatever let you better describe how the interface is changing, but you'll still need to consume/produce new data, FE & BE changes.

So it lets you instead write:

... → [Raw Database Schema] → [Internal Business Object in elixir] → [Server rendering in elixir & HEEx on server] → [Serialize LV updates] → [LV FE lib renders on browser]

Bennies

By regarding the produced DOM mirror as a server API, you can feel ok about writing custom display queries and privileged business model access in your backend code. It means you're not using your RESTful GET endpoints in this codepath, but it also means you're not spitting out that boilerplate with only one current caller that will never have a second caller...

By sending browser events to the server's mirror of the DOM, you don't need to dip into the browser behavior; you can write server code that responds to the user's semantic actions. One can go too far; probably most confirm modals etc should get maintained & triggered clientside, but liveviewers usually take the serverside loop.

This websocket is critical for scoping changes, because e.g. a form post down in the guts of the page might cause changes at distant locations in the DOM (a nested delete button deleting an element from a list?) and the client's browser needs to be told to do the refresh of those elements (the list and any changed elements and a parent object with an element count and...?). That didn't use server generated events, but those could exist too ofc.

How does Elixir keep getting away with it?!

The pat answer for how Liveview does this -- including Chris McCord's article -- is the Blazingly! Efficient! Nature! of the BEAM! VM! (everything is green threads; cluster routing of method calls and replication of state; resumption of failed units of computation, etc etc).

I'm incredibly suspicious of this.

Sure, BEAM solves these problems for the developer, but so does a redis instance (or just the DB you were using anyway! Postgres is no joke!) + frameworks. Lots of apps use session state and use adapters to store that state durably with the end dev not needing to get into the weeds about how. Library authors could do this. It might be easier or harder for a given library author to deliver this in a given language, but there are some very skilled library authors out there.

You, developer, do not yet have as many users as you hope. DevOps has deployment practices that BEAM does not fit into. BEAM's enormous multiplexing is not saving you more than just turning up a few more servers would. You would be writing in go or in c++ if you meant it.

So:

Why isn't there already a popular equivalent of LV in js/ts/py/php/kotlin/etc?

TL;DR: LiveviewJS seems like the closest/most complete option as I understand it.

There are other equivalents ofc. But they have nowhere near the same level of use, despite being in languages that are OoM more in-use.

Candidates include turbo, django unicorn, unpoly, React Server Components... But none are really right afaict!

I can kind of guess why they're not as popular, which is that if you do not need to tie up server assets on a per-client basis, you will not choose to tie up server assets on a per-client basis. Websocket state, client DOM mirrors, etc; it adds up.

If you're building a chat app or video app, obviously devoting a stateful local socket-per-client is a good tradeoff. But I feel like there are lots of models that are similar! Including the one my friend is facing, modifying a document with a lot of spooky action at a distance.

What's missing? The last mile(s)

We have the technology to render any given slice of the page on the server. But AFAIK there's no diff behavior or anything so it'll render the entire subtree. You can choose whether to ship back DOM updates or fully rendered HTML; it doesn't make much of a difference to my point IMO.

Using something like htmx, you could have a frontend form post cause a subtree of the DOM to get re-rendered on the backend and patched back into the document.

That's "fine" so far as it goes, but if (in general) a form post changes components at a distance and you're trying to avoid writing custom frontend-y code for this, you're going to need to target some fairly root component with the changed htmx and include a lot of redundancy -- a SPA that does a refresh of the whole business model.

Why aren't more people talking about this?

The pieces of architecture feel like things we've all had available for a while: websockets, servers that handle requests and websockets, session state, DOM diffing, DOM patching.

How did Elixir get there first (Chris McCord explains how he got there first, so that might just be the answer: spark of genius)? Why did nobody else follow? Is there just a blindingly obvious product out there that does it that I'm missing?

One thing I see is that the big difference is only around server pushed events. Remix/RSC gets us close enough if the browser is always in control. If it isn't, you gotta write your own notification mechanisms -- which you can do, but now you gotta do it, and they're definitely running on the client, and your product has taken on a whole notification pipeline thing.

[sagethemes]

these are the icons used in this theme

[holyjak]

flex is a library for building computations using signals in Clojure(Script) - an approach made popular by SolidJS and others, recently. A "signal" is a reactive data holder, which updates when any of its dependencies change.

[this-week-in-rust]

This Week in Rust 473

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

Launching the 2022 State of Rust Survey

Foundation

Welcoming Shopify as Our Inaugural Gold Member

Newsletters

This Month in Rust OSDev: November 2022

Project/Tooling Updates

rust-analyzer changelog #159

Making Dioxus (almost) as fast as SolidJS

Announcing Ksunami v0.1.x

Fornjot (code-first CAD in Rust) - Weekly Release

Youki v0.0.4 Release

Observations/Thoughts

Catch 22! Rust in Review

A Look at dyn* Code Generation

Shopify Embraces Rust for Systems Programming

Rust in 2023

Category Theory with Rust (pt2) - GATs example

Rust: state of GUI, from the perspective of KAS

A call for blogs about Rust GUI in 2023

[video] Next Generation i18n with Rust Using ICU4X

[video] Supercharging Zero-Copy Deserialization

[video] Let's write a TCP Port Scanner in Rust

[video] Rust Is Easy (The COMPILER teaches you!)

[audio] Presser with Gray Olson

[audio] Kernel Density Estimation with Seaton Ullberg

Rust Walkthroughs

Clean Code with Rust & Axum

Data-driven performance optimization with Rust and Miri

Embedded Rust & Embassy: Analog Sensing with ADCs

Sorting with SIMD

Sending Emails from the Edge with Rust

Composing an observable Rust application

Miscellaneous

[video] Meetup: Rust in critical infrastructure, Amsterdam 30 Nov 2022

Crate of the Week

This week's crate is lazy_format, a lazy version of format! for more efficient composed string formatting operations.

Thanks to Nathan West for the self-suggestion!

Please submit your suggestions and votes for next week!

Call for Participation

Always wanted to contribute to open-source projects but didn't know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

* impl-tools - more testing more context * time - more testing more context * Ockam - Refactor request_controller function to accept an optional Identity * Ockam - Add optional --identity argument to secure-channel create and modify implementation on ockam_api

If you are a Rust project owner and are looking for contributors, please submit tasks here.

Updates from the Rust Project

320 pull requests were merged in the last week

add LLVM KCFI support to the Rust compiler

add StableOrd trait

add help for #![feature(impl_trait_in_fn_trait_return)]

compute generator sizes with -Zprint_type_sizes

consider parent_count for const param defaults

detect long types in E0308 and write them to disk

detect spurious ; before assoc fn body

disable top down MIR inlining

don't ICE in ExprUseVisitor on FRU for non-existent struct

don't call diagnostic_hir_wf_check query if we have infer variables

don't internalize __llvm_profile_counter_bias

enable ThinLTO for rustc on x86_64-apple-darwin

enable ThinLTO for rustc on x64 msvc

enable profiler in dist-powerpc64le-linux

fix build on powerpc-unknown-freebsd

fix invalid codegen during debuginfo lowering

fix lint perf regressions

group some fields in a common struct so we only pass one reference instead of three

interpret: clobber return place when calling function

llvm-wrapper: adapt for LLVM API changes

llvm-wrapper: adapt for an LLVM API change

make VecDeque::from_iter O(1) from vec(_deque)::IntoIter

make integer-to-integer From impls #[inline(always)]

make pointer sub and wrapping_sub methods #[inline(always)]

make some trivial functions #[inline(always)]

mangle "main" as "__main_void" on wasm32-wasi

on E0195 point at where clause lifetime bounds

point at GAT where clause when an obligation is unsatisfied

point at LHS on binop type err if relevant

point at args in associated const fn pointers

re-enable removal of ZST writes to unions

recurse into nested impl-trait when computing variance

remove token::Lit from ast::MetaItemLit

remove {Early, Late}LintPassObjects

shrink rustc_parse_format::Piece

suggest parenthesis around ExprWithBlock BinOp ExprWithBlock

suggest removing struct field from destructive binding only in shorthand scenario

tweak "the following other types implement trait"

tweak rustc_must_implement_one_of diagnostic output

miri: allow configurable and platform-specific page sizes

miri: make unix path handling on Windows hosts (and vice versa) preserve absoluteness

cargo: allow Check targets needed for optional doc-scraping to fail without killing the build

rustdoc: only hide lines starting with # in rust code blocks

rustdoc: prevent auto/blanket impl retrieval if there were compiler errors

clippy: arithmetic-side-effects: consider user-provided pairs

clippy: uninlined_format_args:ignore assert! and debug_assert! before 2021 edition

clippy: add 1.58 MSRV for collapsible_str_replace

clippy: add suppress_restriction_lint_in_const config

clippy: add lint almost_complete_digit_range

clippy: add semicolon-outside/inside-block lints

clippy: don't suggest keeping borrows in identity_op

clippy: fix zero_ptr suggestion for no_std crates

rust-analyzer: compute data layout of types

rust-analyzer: add "Remove redundant parentheses" assist

rust-analyzer: add fallback case in generated PartialEq impl

rust-analyzer: allow unwrap block in let initializers

rust-analyzer: breaking snippets on typed incomplete suggestions

rust-analyzer: don't show duplicated adjustment hints for blocks, ifs and matches

rust-analyzer: fix parsing of _ = x in closure body

rust-analyzer: make make_body respect comments in extract_function

rust-analyzer: normalize projection after discarding free BoundVars in RPIT

rust-analyzer: only shift BoundVars that come from outside lowering context

rust-analyzer: show type info on hover of enum variant fields

Rust Compiler Performance Triage

Fairly quiet week with the only excitement coming from a nice improvement implemented by @nnethercote which fixed a pesky performance regressions in the linting system. This produced a 0.6% performance improvement across a large amount of the real world crates we test against.

Triage done by @rylev. Revision range: 9db224fc..109cccbe

Summary:

(instructions:u) mean range count Regressions ❌ (primary) 0.2% [0.2%, 0.2%] 3 Regressions ❌ (secondary) 1.7% [0.3%, 3.3%] 11 Improvements ✅ (primary) -0.8% [-2.2%, -0.2%] 129 Improvements ✅ (secondary) -1.2% [-4.4%, -0.1%] 97 All ❌✅ (primary) -0.7% [-2.2%, 0.2%] 132

2 Regressions, 2 Improvements, 4 Mixed; 3 of them in rollups 41 artifact comparisons made in total

See the full report for details.

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

Support upcasting of dyn Trait values

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

[disposition: merge] Add core::mem::offset_of! RFC

[disposition: close] Cargo allow running binaries from development or build dependencies

Tracking Issues & PRs

[disposition: merge] Stabilize #![feature(target_feature_11)]

[disposition: merge] Stabilize default_alloc_error_handler

[disposition: merge] Stop promoting all the things

[disposition: merge] Arc::ptr_eq does not always return "true if the two Arcs point to the same allocation" as documented

[disposition: merge] Don't normalize in AstConv

[disposition: merge] Encode spans relative to the enclosing item -- enable by default

[disposition: merge] impl DispatchFromDyn for Cell and UnsafeCell

[disposition: merge] Tracking issue for the "efiapi" calling convention

New and Updated RFCs

[new] RFC: Start working on a Rust specification

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

No RFCs issued a call for testing this week.

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Upcoming Events

Rusty Events between 2022-12-14 - 2023-01-11 🦀

Virtual

2022-12-14 | Virtual (Boulder, CO, US) | Boulder Elixir and Rust

Monthly Meetup

2022-12-24 | Virtual (Linz, AT) | Rust Linz

Rust Meetup Linz - 28th Edition

2022-12-14 | Virtual (México City, MX) | Rust MX

Rust y Arduino

2022-12-15 | Virtual (Stuttgart, DE) | Rust Community Stuttgart

Rust-Meetup

2022-12-20 | Virtual (Berlin, DE) | Berlin.rs

Rust Hack and Learn

2022-12-20 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2022-12-21 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Show & Tell: Tableturf

2022-12-27 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2023-01-03 | Virtual (Beijing, CN) | WebAssembly and Rust Meetup (Rustlang)

Monthly WasmEdge Community Meeting, a CNCF sandbox WebAssembly runtime

2023-01-03 | Virtual (Berlin, DE) | OpenTechSchool Berlin

Rust Hack and Learn

2023-01-03 | Virtual (Buffalo, NY, US) | Buffalo Rust Meetup

Buffalo Rust User Group, First Tuesdays

2023-01-04 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2023-01-04 | Virtual (Stuttgart, DE) | Rust Community Stuttgart

Rust-Meetup

2023-01-05 | Virtual (Charlottesville, VA, US) | Charlottesville Rust Meetup

Part 2: Exploring USB with Rust

Asia

2022-12-29 | Tel Aviv, IL | Rust TLV

December Edition - xtask, macros and low level features

Europe

2022-12-14 | Trondheim, NO | Rust Trondheim

Rust Advent of Code hackathon

2022-12-15 | Stuttgart, DE | Rust Community Stuttgart

OnSite Meeting

North America

2022-12-14 | Austin, TX, US | Rust ATX

Rust Lunch

2022-12-20 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2022-12-27 | Austin, TX, US | ATX Rustaceans

Atx Rustaceans Meetup

2023-01-05 | Lehi, UT, US | Utah Rust

Interesting Title and Food!

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

... you can lead a horse to git but you cannot make it commit.

– /u/kibwen on /r/rust

Thanks to Anton Fetisov for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[devsnews]

This week's issue contains some of the most interesting articles and news, selected from all the content published in the previous week on the Developers News website. You will read about Comparing The Cloud Leaders, Machine learning with Julia, Testing JavaScript, Gopaddle, Java vs. Python, Bash scripting, Concurrency in Serverless, Kubernetes Deployments, SolidJS , and more

[meagcourses]

Build A TodoList with Elixir, Phoenix and SolidJs - https://megacourses.net/build-a-todolist-with-elixir-phoenix-and-solidjs/