Hasty Briefsbeta

All tags

#web development

328 stories total

Bilingual

There Is a Monster in the Forest
a year ago
- The web application is heavily interactive and requires JavaScript.
- Simple HTML interfaces are possible but not applicable here.
- The post is from joles.bsky.social with DID: plc:3kssplu7pwdx7cmntm7jgzze.
- The user mentions they are applying for jobs again.
- The post was made on May 5, 2025, at 14:03:05.498Z.
The Height Enigma (CSS)
a year ago
- CSS height property sometimes doesn't work due to circular calculations between parent and child elements.
- Width and height in CSS are calculated differently; width depends on the parent, while height depends on children.
- Percentage-based heights require the parent to have a 'knowable' height, not dependent on children.
- Using explicit heights (like px or rem) on parents allows percentage heights to work on children.
- The root <html> tag can use height: 100% because it references the viewport, not a parent element.
- Flexbox and Grid layouts can help avoid height issues by changing how elements fill available space.
- Min-height doesn't resolve circular height issues because it still depends on children's content.
- CSS layout algorithms (Flow, Flexbox, Grid) behave differently, affecting how heights are calculated.
Ports that are blocked by browsers
a year ago
- Experimenting with Docker and Flask revealed that some ports are blocked by browsers due to security vulnerabilities.
- Port 6000 was blocked by Chrome, Safari, and Firefox, each displaying different error messages for the same issue.
- The blocking is due to Cross-protocol scripting vulnerabilities, preventing attacks on services like IMAP, SMTP, and others.
- Firefox provides the most informative message, indicating the request is canceled before reaching the server.
- Using cURL bypasses browser restrictions, proving the issue is browser-specific.
- A list of commonly blocked ports includes those used for FTP, SSH, SMTP, and other services to prevent exploitation.
Why I Use WebAssembly
a year ago
- WebAssembly (WASM) enables running native code like FFmpeg directly in the browser, transforming web applications.
- WASM improves performance, as seen with Figma's 3x load time reduction using a C++ renderer.
- WASM's isolation properties make it useful beyond browsers, potentially replacing technologies like Docker.
- Client-side WASM eliminates server round trips, simplifying state management in applications like file converters.
- WASM allows sharing core logic across platforms, reducing the need for separate codebases for web and native apps.
- Tauri is highlighted as a lightweight alternative to Electron, using system web views for native apps with web UIs.
- Nema Studio exemplifies using WASM for a cross-platform DAW, targeting browser users before encouraging native app adoption.
Stop using REST for state synchronization (2024)
a year ago
- REST is cumbersome for state synchronization in webapps.
- State transfer protocols like REST lead to repetitive and brittle code.
- Example shows issues with REST in a simple text input scenario.
- Problems include request ordering, spinner logic, and state divergence.
- State synchronization mechanisms like CRDTs could be a better solution.
- Current tools (Automerge, Yjs, Braid, Electric SQL) are promising but need maturity.
- Optimizing for local-first scenarios may not address common webapp needs.
Just Fucking Use React
a year ago
- React (or similar frameworks) are essential for building complex, interactive web applications, not just static pages.
- Components in frameworks like React allow for reusable, encapsulated UI elements, improving maintainability and consistency.
- Frameworks handle smarter UI updates, optimizing performance by only redrawing necessary parts of the page.
- Accessibility at scale is more manageable with frameworks, ensuring complex UIs remain accessible without manual effort.
- Developer experience (DX) is significantly better with frameworks, offering tools like hot module replacement and TypeScript integration.
- Performance in frameworks isn't just about initial load but also perceived performance and interaction smoothness.
- Frameworks are suitable for applications with non-trivial client-side state, reusable UI components, and complex interactions.
- The real issue isn't the framework but developers misusing tools for inappropriate tasks.
- For complex applications, using a framework like React is recommended over vanilla JS for better maintainability and efficiency.
Popcorn: Run Elixir in WASM
a year ago
- Popcorn is a library that enables execution of Elixir code within web browsers using WASM.
- Compiled Elixir code runs in the client-side AtomVM runtime, with APIs for JS-Elixir interaction.
- Popcorn provides serialization, communication handling, and ensures browser responsiveness.
- Setup involves adding Popcorn as a dependency, configuring JS and Elixir WASM entrypoints.
- JS setup includes generating directories for WASM and including scripts in HTML.
- Elixir requires a WASM entrypoint module with a `start/0` function and configuration.
- Communication between JS and Elixir is managed via messages and direct JS execution from Elixir.
- Popcorn's API includes methods for sending messages, executing JS, and handling events.
- Limitations include missing NIFs from OTP, no support for big integers, and unstable API.
- Under the hood, Popcorn uses AtomVM runtime compiled via Emscripten, loaded in an iframe.
- Popcorn is created by Software Mansion, experts in web, mobile, and multimedia solutions.
CSS Attr() Gets an Upgrade
a year ago
- The redesigned CSS `attr()` function now works with any CSS property, not just the `content` property of pseudo-elements.
- It can parse HTML attribute values into various CSS data types, such as `<color>`, `<custom-ident>`, and length units like `px`.
- Examples include using `attr()` to set `color` from a `data-color` attribute and `view-transition-name` from an element's `id`.
- The function supports fallback values, e.g., `attr(data-foo type(<color>), red)` defaults to `red` if parsing fails.
- Without a specified type, `attr()` defaults to parsing as a CSS string, maintaining backward compatibility.
Really Really Simple "Pure CSS" Squircles
a year ago
- Pure CSS Squircle is a desired feature for web developers.
- Using SVG for clipping is complex and has performance issues.
- CSS Houdini can render squircle but lacks Safari support and isn't Pure CSS.
- The CSS `shape()` function is now supported in major browsers.
- A code snippet is provided to create a squircle effect using `clip-path` and `shape()`.
Ash AI: A Comprehensive LLM Toolbox for Ash Framework
a year ago
- Ash Framework is a declarative, resource-oriented backend framework for Elixir.
- It simplifies web app development by focusing on resources as core building blocks.
- Ash automates backend tasks like schema generation, API creation, and authorization.
- Key features include generated APIs, built-in security, real-time systems, and easy migrations.
- Ash complements Phoenix, handling the application layer while Phoenix manages the web layer.
- It is suitable for greenfield projects, scaling up, and incremental migration in brownfield projects.
- Ash supports high performance, observability, and seamless deployment.
- The framework has a growing community and extensive documentation.
- Common misconceptions include concerns about rigidity, learning curve, and production readiness.
OCaml Web Development: Essential Tools and Libraries in 2025
a year ago
- OCaml is gaining momentum in web development due to its functional programming benefits like immutability and scalability.
- Key OCaml web frameworks include Ocsigen (full-stack), Dream (backend), and Bonsai (frontend).
- Ocsigen offers multi-tier programming, allowing client and server code to be written in OCaml as a single program.
- Dream is a minimalist, configurable backend framework with strong developer experience and security features.
- Bonsai is a client-side framework by Jane Street, enabling scalable and interactive UIs with OCaml.
- OCaml integrates with JavaScript and WebAssembly via tools like Js_of_ocaml, Wasm_of_ocaml, and Melange.
- Melange provides seamless JavaScript interoperability, making OCaml a viable alternative to TypeScript.
- OCaml-vdom implements an Elm-like architecture for reactive web interfaces in OCaml.
- MirageOS offers lightweight unikernel deployment for secure, efficient microservices.
- OCaml supports static site generation with tools like Soupault, Stog, and YOCaml.
Don't Guess My Language
a year ago
- IP geolocation should not be used to determine language preferences as it is unreliable.
- Countries often have multiple official languages, making IP-based language assumptions incorrect.
- Browsers send an 'Accept-Language' header which accurately reflects user language preferences.
- Forcing a language based on IP can frustrate users, especially those using VPNs or traveling.
- The best practice is to use the 'Accept-Language' header and allow users to manually change the language if needed.
- GeoIP can be used for other purposes like currency or shipping, but not for language.
Have I Been Pwned 2.0 is Now Live
a year ago
- The new Have I Been Pwned (HIBP) website is now live after a long development process.
- Key features include an improved search function with celebratory confetti for some users, emphasizing a playful and approachable design.
- Username and phone number search support has been removed from the website but remains available via the API.
- A new dedicated breach page provides detailed information and actionable advice for users affected by data breaches.
- The dashboard has been unified to centralize all features requiring email verification, with plans for future enhancements like passkey support.
- The domain search feature has been significantly overhauled, offering cleaner results and new filtering options.
- The API remains unchanged, with plans to update documentation to OpenAPI standards in the future.
- A new merch store has been launched, offering HIBP-branded products at cost price.
- Technical improvements include reduced page size and requests, and the use of modern frameworks like Bootstrap and TypeScript.
- AI tools like ChatGPT were extensively used during the rebuild for tasks ranging from icon selection to scripting.
- The launch involved extensive behind-the-scenes work, including legal updates and health challenges for the team.
Biff – a batteries-included web framework for Clojure
a year ago
- Biff curates libraries and tools from the ecosystem into a polished whole.
- Biff brings immutability to databases with schema enforcement using Malli.
- Enables rich, interactive UIs from the backend with optional _hyperscript for client-side scripting.
- Offers passwordless, email-based authentication with magic links and one-time passcodes.
- Supports provisioning an Ubuntu VPS or deploying an Uberjar with Docker.
- Features live code evaluation on file save and REPL connectivity for on-the-fly development.
- Provides a tutorial, reference docs, and a starter project with doc strings for exploration.
Clojuring the web application stack: Meditation One
a year ago
- The post discusses the lack of a canonical web framework in Clojure, emphasizing the need to understand both web framework and application architecture.
- It introduces the Ring project as the canonical HTTP library collection in Clojure, highlighting its design choices and influence on the ecosystem.
- The author provides a bare-minimum web app example using Ring and Jetty, demonstrating request/response handling with Clojure hash-maps.
- Middleware in Ring is explained as a functional mechanism for handling cross-cutting concerns like state management, error handling, and request/response transformations.
- Routing is identified as a critical piece not included in Ring, with libraries like Compojure and Reitit recommended for polymorphic dispatch.
- The post concludes with practical advice for beginners, suggesting starting with Ring + Jetty + Compojure + Hiccup + next-jdbc and exploring more advanced stacks like Kit, Biffweb, and Edge.
Slack, Notion, and VSCode Improved Electron App Performance
a year ago
- Electron apps can rival native app performance with proper optimization.
- Main performance challenges: slow startup and poor interaction performance.
- Key strategies include using bundlers (Webpack, esbuild, Vite) to replace synchronous `require()` calls.
- Defer non-critical imports using route-based code splitting and async imports.
- Migrate computationally expensive tasks to WebAssembly or native modules for better performance.
- Use V8 snapshots to reduce initialization time, as demonstrated by Atom and VSCode teams.
- Monitor end-user performance metrics like click latency, keypress latency, and scroll latency.
- Implement production JavaScript profiling to identify and fix performance bottlenecks.
- Notion improved performance metrics by 15-20% using production profiling tools like Palette.
HTML5 elements you didn't know you need
a year ago
- HTML5 includes powerful native elements often overlooked in favor of JavaScript libraries.
- The <dialog> element provides native modal window functionality with built-in accessibility.
- <details> and <summary> elements create collapsible sections without JavaScript.
- The <datalist> element offers native autocomplete functionality for input fields.
- <meter> displays values within a range with semantic coloring based on thresholds.
- <output> is a dedicated element for showing calculation results in forms.
- <mark> provides semantic highlighting for text, useful in search results.
- <time> semantically marks up dates and times with machine-readable formats.
- <figure> and <figcaption> properly structure captions for images and other media.
- Using these native elements reduces JavaScript dependency and improves accessibility.
Tab Roving – focus management for element groups
a year ago
- Focus management in interactive data grids is challenging, especially for keyboard users.
- Tab roving improves navigation by allowing arrow keys to move focus within the grid, treating it as a single interactive element.
- The `tabindex` attribute is crucial for controlling focus order and making elements tabbable or non-tabbable.
- Implementing tab roving involves tracking the focused element, handling key presses, and programmatically updating focus.
- React can be used to manage state and refs for dynamically updating the focused cell in a grid.
- Additional accessibility improvements include shortcuts for navigation and considering edge wrapping behavior.
- Tab roving is applicable beyond grids, such as in mega menus or custom numerical inputs.
Wake Up, Remix
a year ago
- Remix was announced to 'take a nap' at React Conf last summer.
- Remix v2 became a thin wrapper around React Router, leading to an artificial separation between the projects.
- Bundler and server runtime code from Remix were moved into React Router v7, merging Remix's features into React Router's 'framework mode'.
- React Router v7 was released last November with RSC support previewed last week, providing a stable platform for Remix v1 and v2 users.
- React Router v7 has become highly capable, supporting server components directly from loaders and actions, and offering server-only routes.
- React Router v7 is widely used by major companies like Shopify, X.com, GitHub, and powers nearly 11 million GitHub projects.
- Remix v3 is being reimagined as a full-stack, RSC-first React framework with a focus on simplicity, clarity, and performance.
- Remix v3 aims to be a modular toolkit with first-class database drivers and a built-in component library, starting with a fork of Preact.
- Development principles for Remix v3 include lightweight, fast, and web-aligned experiences, with no critical dependencies, not even React.
- A preview release is not ready yet, but progress will be shared at Remix Jam.
An Interactive Guide to Flexbox in CSS
a year ago
- Flexbox is a powerful layout mode for creating dynamic and responsive layouts.
- Flexbox properties include `flex-direction`, `justify-content`, `align-items`, `flex-grow`, `flex-shrink`, and `flex-basis`.
- Flexbox uses a primary and cross axis system, with alignment controlled via `justify-content` (primary axis) and `align-items` (cross axis).
- `flex-grow` and `flex-shrink` control how items expand or contract to fill available space or avoid overflow.
- `flex-basis` sets the initial size of an item along the primary axis, similar to `width` or `height`.
- The `gap` property adds spacing between Flexbox items, improving layout quality.
- Auto margins in Flexbox can be used to distribute extra space precisely.
- `flex-wrap` allows items to wrap onto multiple lines, creating multi-row/column layouts.
- The `min-width` and `min-height` properties can override default minimum sizes to prevent unwanted shrinking.
- Flexbox is ideal for one-dimensional layouts, while CSS Grid is better for two-dimensional layouts.

first prev2next

About|Login

#web development

There Is a Monster in the Forest

The Height Enigma (CSS)

Ports that are blocked by browsers

Why I Use WebAssembly

Stop using REST for state synchronization (2024)

Just Fucking Use React

Popcorn: Run Elixir in WASM

CSS Attr() Gets an Upgrade

Really Really Simple "Pure CSS" Squircles

Ash AI: A Comprehensive LLM Toolbox for Ash Framework

OCaml Web Development: Essential Tools and Libraries in 2025

Don't Guess My Language

Have I Been Pwned 2.0 is Now Live

Biff – a batteries-included web framework for Clojure

Clojuring the web application stack: Meditation One

Slack, Notion, and VSCode Improved Electron App Performance

HTML5 elements you didn't know you need

Tab Roving – focus management for element groups

Wake Up, Remix

An Interactive Guide to Flexbox in CSS