Hasty Briefsbeta

All tags

#web development

328 stories total

Bilingual

Crafting your own Static Site Generator using Phoenix (2023)
9 months ago
- Introduction to building a Static Site Generator (SSG) from scratch using Elixir.
- Use of NimblePublisher for Markdown and Front Matter parsing.
- Integration of Phoenix Components for HTML rendering.
- Setup of Tailwind and Esbuild for CSS and JavaScript processing.
- Automation of build processes with Mix tasks.
- Deployment strategy using Docker and Fly.io.
- Emphasis on the simplicity and power of Elixir for static site generation.
PHP-ORT: Machine Learning Inference for the Web
9 months ago
- Software and machine learning are evolving rapidly, making ML essential for all digital interactions.
- PHP developers face a challenge to stay relevant in an AI-first world to protect their careers and livelihoods.
- PHP dominates the web with 78% usage but lacks first-class ML support, forcing developers to use inefficient workarounds.
- PHP-ORT introduces production-ready ML inference to PHP, enabling developers to build intelligent applications easily.
- PHP-ORT features include a Tensor API, high-performance math library, ONNX integration, and SIMD acceleration.
- The solution aims to complement Python (for training) with PHP (for inference), not replace it.
- Key innovations include immutable tensors, dual storage class tensors, and optimized memory management.
- PHP-ORT is production-ready, with rigorous engineering, performance benchmarks, and easy installation.
- The project addresses criticisms about PHP's suitability for ML, emphasizing ecosystem growth and foundational infrastructure.
- The goal is to democratize ML for PHP developers, enabling innovation and keeping PHP relevant in an AI-driven future.
Ladybird Browser July Update
9 months ago
- 319 pull requests merged from 47 contributors in July.
- New sponsors: Scraping Fish ($5,000) and Blacksmith (CI infrastructure).
- Web Platform Tests (WPT) progress: 13,090 new passing tests (total 1,831,856).
- Google reCAPTCHA now passes due to a fix in postMessage implementation.
- High refresh rate support added (up to 120Hz for requestAnimationFrame).
- HTTP/3 support enabled via curl 8.14.0 and OpenSSL backend.
- Initial Trusted Types support added for security against XSS.
- Major SVG foreignObject improvements for better HTML-SVG integration.
- CSS content: url(...) support added for pseudo-elements.
- New pseudo-classes: :state(foo) and :unchecked.
- Logical property groups now generated at compile time.
- Arbitrary substitution functions (var(), attr()) rewritten for spec compliance.
- CSS <syntax> parsing support added for attribute values.
- Progress on @property and CSS.registerProperty().
- LibJS transitioned to native UTF-16 strings for web compatibility.
Show HN: Spatial Web Browser Engine
9 months ago
- Every HTML element is spatially rendered in the browser using JSAR.
- Web developers can create immersive experiences with HTML5, CSS3, and TypeScript.
- JSAR supports modern Web standards; check Browser Compatibility Data for details.
- Guides available for building first spatial web applications.
- Join a community of developers working on the spatial web.
The Toyota Corolla of programming
9 months ago
- PHP and JavaScript were both released in 1995 and became foundational for web development.
- Both languages faced criticism but grew to power a significant portion of the web.
- PHP and JavaScript received standardization in 1997 and major tech support in the 2010s.
- PHP is often mocked but powers 70-80% of websites, offering affordability and ease of use.
- Modern PHP includes OOP features, functional programming constructs, and a robust ecosystem.
- PHP's evolution includes annual stable releases and security improvements.
- FrankenPHP, a new runtime, aims to modernize PHP for DevOps and containerized environments.
- Despite improvements, PHP continues to face stigma from its early design flaws.
- PHP's community-driven development has been key to its longevity and success.
A Few Things About the Anchor Element's Href You Might Not Have Known
9 months ago
- Anchor element's href attribute can use various protocols like mailto:, tel:, sms:, and javascript:.
- Protocol-relative links can be used with href="//".
- Text fragments allow linking to specific text on a page using href="#:~:text=foo".
- href="#" or href="#top" scrolls to the top of a document.
- href="" reloads the current page, preserving the search string but removing the hash.
- href="." reloads the current page, removing both search and hash strings, but requires trailing slashes for correct behavior.
- href="?" reloads the current page, removing search parameters and hash but preserves the ? character.
- Data URLs can be used with href="data:text/plain,hello%20world" to navigate to plain text.
- Media fragments like href="video.mp4#t=10,20" allow linking to specific parts of media files.
- JavaScript's URL constructor can be used to test how different href values resolve.
What Is Popover=Hint?
9 months ago
- The `popover="hint"` attribute in HTML allows opening a hint popover without closing other popovers in the stack.
- This is useful for tooltips or preview cards, like profile previews on Twitter or Facebook.
- Three types of popovers exist: `auto`, `manual`, and `hint`, each with different behaviors regarding light dismiss and closing other popovers.
- A demo shows how a `hint` popover can stay open while an `auto` popover remains active, though clicking the `hint` popover may close the `auto` one.
- JavaScript event listeners are needed to manage hover and keyboard interactions for `hint` popovers.
- Experimental `interestfor` API enables declarative hover/focus-based popovers without JavaScript, currently behind a flag in Chrome Canary.
- `popover="hint"` and `interestfor` simplify building layered UI elements like tooltips and previews.
HTML Is Dead, Long Live HTML
9 months ago
- The DOM has become bloated with over 350+ keys in Chrome's document.body and 660 CSS properties, making it complex and inefficient.
- Web Components and Semantic HTML have failed to meet expectations, with clunky APIs and unclear guidelines.
- CSS layout models are confusing, with inside-out and outside-in approaches leading to unpredictable behavior.
- SVG and CSS overlap but have inconsistencies, making graphical rendering a trade-off between the two.
- Proposals like HTML in Canvas are flawed, as they don't solve core issues and introduce new complexities.
- Alternative approaches, like Use.GPU's HTML-like renderer, demonstrate that simpler, more efficient solutions are possible.
- Browser vendors and alt-browser projects (e.g., Servo, Ladybird) could lead the way in rethinking the DOM from scratch.
- A redesigned DOM should prioritize multi-threading, security, and modern UI needs while shedding legacy baggage.
Phoenix 1.8.0 Released
9 months ago
- Phoenix 1.8.0 released with quality-of-life improvements.
- New apps include AGENTS.md for enhanced LLM-assisted development.
- Dark mode support added for better UX.
- Magic link authentication now default in phx.gen.auth.
- Introduction of scopes for secure and scalable data access.
- Integration of daisyUI for Tailwind theming and components.
- Streamlined onboarding with simplified code generators.
- Revised nested layouts for better customization.
- Backwards compatible release with some deprecations.
Litestar Is Worth a Look
9 months ago
- Litestar is an async-first, type-hint-driven Python web framework that stands out for its simplicity and flexibility.
- Unlike frameworks like FastAPI, Litestar's route decorators are standalone functions, avoiding circular import issues in multi-file applications.
- Litestar supports multiple schema definitions (Pydantic, dataclasses, msgspec) and offers DTO helpers to reduce boilerplate and errors.
- It provides excellent SQLAlchemy integration, including automatic repository implementations and service-layer abstractions via Advanced Alchemy.
- Litestar's architecture is reminiscent of Spring Boot, offering a microframework feel with the scalability of larger frameworks.
Show HN: Aura – Like robots.txt, but for AI actions
9 months ago
- AURA is an open protocol designed to make websites understandable and operable by AI agents.
- It introduces a standardized machine-readable layer for the internet, moving beyond screen scraping and DOM manipulation.
- AURA uses a manifest file (aura.json) to declare website capabilities in a standardized format.
- Capabilities are discrete actions an agent can perform, each mapping to a specific HTTP request.
- The protocol includes a dynamic HTTP header (AURA-State) for context and available capabilities.
- The repository includes core packages, a reference server, and a reference client for implementation.
- Demonstrations include running a server, using an agent to execute capabilities, and a crawler for indexing.
- AURA aims for community adoption with adapters for web frameworks and clients in various languages.
- It is positioned as a public good to foster a more intelligent and interoperable web.
Infinite Pixels
9 months ago
- The author explores the behavior of CSS when using 'infinity' in pixel calculations across different browsers.
- Safari and Chrome compute values close to 2^25-1 (33,554,431) for width and height, with slight variations.
- Firefox exhibits odd behavior, with computed height values based on default line height and width values that are halved in layout.
- Font size tests with 'infinity' reveal hard limits in Safari (100,000px) and Chrome (10,000px), while Firefox uses a 32-bit floating-point number.
- Line height tests with 'infinity' show similar results to width and height tests, with Firefox's computed and layout values differing significantly.
- The author invites explanations for these behaviors and hints at further experiments with negative infinity in CSS.
HTTP Is Not Simple
9 months ago
- HTTP is not a simple protocol, despite common misconceptions.
- HTTP/1 may appear simple due to readable text and basic use cases, but its machinery is complex.
- HTTP/1.1 introduced features like pipelining and 100 response codes that are rarely used and complicate implementations.
- HTTP headers can be arbitrarily long, use different line endings, and may be folded or merged, adding complexity.
- Determining the end of a HTTP/1 body is not straightforward, with multiple methods like Content-Length, chunked encoding, and Connection: close.
- Parsing numbers in HTTP is slow and error-prone due to various formats and potential issues like integer overflows.
- HTTP/1.1 specs have grown significantly over time, from 18,615 words in HTTP/1.0 to over 95,740 words in the latest HTTP/1.1 documents.
- Modern HTTP implementations must support additional features like cookies and authentication, which are not part of the main HTTP spec.
- HTTP methods and headers are not uniformly implemented, leading to interoperability issues.
- Browser implementations often prioritize user experience over strict protocol adherence, influencing HTTP behavior.
- HTTP/1 remains widely used despite its complexity, especially in small applications and IoT, due to its efficiency and low CPU usage.
- Future HTTP versions are expected to add more complexity, continuing the trend of protocol evolution.
Events
9 months ago
- Events are actions or occurrences that happen in the system, which the system notifies the code about to react.
- Events can be user interactions like clicks, key presses, or system actions like page loading or form submissions.
- Event listeners are used to detect events, and event handlers are functions that run in response to those events.
- The `addEventListener()` method is the recommended way to attach event listeners to elements.
- Events can be removed using `removeEventListener()` to clean up or change behavior dynamically.
- Multiple event listeners can be attached to the same event, allowing multiple responses to a single event.
- Alternative methods to `addEventListener()` include event handler properties (e.g., `onclick`) and inline event handlers, though the latter is discouraged.
- Event objects provide additional context about the event, such as the target element or specific key pressed.
- Some events can have their default behavior prevented using `preventDefault()`, useful for form validation.
- Events are not limited to web pages; other environments like Node.js or browser extensions have their own event models.
A gentle introduction to anchor positioning
9 months ago
- Anchor positioning allows placing an element based on another element's position, simplifying responsive menus and tooltips with CSS.
- Use `anchor-name` on the anchor element and `position-anchor` on the target to establish a connection.
- Position elements using `position-area` with logical properties like `block-start` and `inline-end` for better inclusivity.
- The `position-try` property helps adjust positioning dynamically when space is limited, such as on mobile devices.
- The `anchor()` function aligns elements based on the edges of the anchor, supporting both physical and logical properties.
- Use `calc()` with `anchor()` to fine-tune positioning, accounting for padding or other offsets.
- Both `position-area` and `anchor()` offer flexible ways to position elements, catering to different mental models.
Show HN: I built a free alternative to Adobe Acrobat PDF viewer
9 months ago
- EmbedPDF is a framework-agnostic, MIT-licensed PDF viewer for any JavaScript project.
- Compatible with React, Vue, Svelte, Preact, and vanilla JS.
- Features include annotations, true redaction, search, text selection, zoom, rotation, and smooth scrolling.
- Offers a pluggable architecture and tree-shakable plugins.
- Encourages contributions with a contributing guide and GitHub discussions.
- Licensed under the MIT License.
Show HN: Modelence – Supabase for MongoDB
9 months ago
- Modelence is an all-in-one TypeScript framework for startups.
- It aims to eliminate boilerplate for standard web app features.
- Features include authentication, database setup, cron jobs, AI observability, and email.
- Quick Start Guide available to begin using Modelence.
CSS custom functions are here!!
9 months ago
- CSS custom functions are now available in Chrome 139, allowing for dynamic and organized CSS.
- The `@function` rule enables logic execution in CSS, accepting arguments and returning values.
- Five practical CSS functions are introduced: negation, opacity adjustment, fluid typography, conditional border radius, and responsive sidebar layout.
- A bonus function extends `light-dark()` theming beyond colors, supporting various style properties.
- Future CSS features like `@mixin` and `@apply` promise even more powerful styling capabilities.
Document.write
9 months ago
- The article discusses the use of `document.write()` for HTML templating in static sites.
- It explains how `document.write()` can be used to insert HTML directly where the function is called.
- Two rules are proposed for safe use of `document.write()`: only call it at the document toplevel or in functions named 'write', and never use it to output `<script>` or `<style>` tags.
- The article highlights the benefits of using `document.write()` for simple sites, such as speed and ease of development.
- It mentions the drawbacks, including the JavaScript requirement and the deprecation of `document.write()`.
- Alternative methods like `document.currentScript.replaceWith()` are suggested for safer in-place element insertion.
- The article concludes with insights on SEO compatibility and the limitations of the discussed techniques.
HTTP Caching
9 months ago
- HTTP caching stores responses for reuse, reducing server load and improving response times.
- Two main types of caches: private (client-specific) and shared (among users).
- Private caches store personalized responses, while shared caches include proxy and managed caches.
- Heuristic caching allows responses to be stored even without explicit Cache-Control headers.
- Fresh and stale states of cached responses are determined by their age relative to max-age.
- Validation mechanisms (If-Modified-Since, If-None-Match) allow stale responses to be refreshed.
- Cache busting involves changing URLs for static resources to enable long-term caching.
- Main resources (like HTML) typically use no-cache to ensure they are always up-to-date.
- Managed caches (CDNs, service workers) offer more control, like purging caches on updates.

first prev6next

About|Login

#web development

Crafting your own Static Site Generator using Phoenix (2023)

PHP-ORT: Machine Learning Inference for the Web

Ladybird Browser July Update

Show HN: Spatial Web Browser Engine

The Toyota Corolla of programming

A Few Things About the Anchor Element's Href You Might Not Have Known

What Is Popover=Hint?

HTML Is Dead, Long Live HTML

Phoenix 1.8.0 Released

Litestar Is Worth a Look

Show HN: Aura – Like robots.txt, but for AI actions

Infinite Pixels

HTTP Is Not Simple

Events

A gentle introduction to anchor positioning

Show HN: I built a free alternative to Adobe Acrobat PDF viewer

Show HN: Modelence – Supabase for MongoDB

CSS custom functions are here!!

Document.write

HTTP Caching