rhdunn

post != article

From https://news.ycombinator.com/item?id=48281764:

> > ARIA can help when devs want to use the wrong elements for some reason or for custom controls.

> But it can't. See this article.

You said "see this article" re: how aria-label is not applicable to div elements, hence the second link which is the WAI-ARIA guide on labelling elements.

You also said that ARIA can't help with custom controls in that post, which is where the other links are applicable as they describe doing just that. I.e. using ARIA tags to implement tabs, accordions, etc. either with or without a framework library.

NVDA is a free screen reader for Windows (written by blind devs) that works with Firefox and Chrome.

You don't need to pay for a specialist browser as all web browsers (Firefox, Chrome, Edge, Safari, etc.) will implement the native accessibility model of the operating system they are running on (IAccessible/MSAA for Windows, etc.).

In Firefox you can press the right mouse button and select "Inspect Accessibility Properties" or select the "Accessibility" tab from the developer window and it will show the accessibility tree (roles, states, properties, etc.) just like the DOM tree in the "Inspect" tab. That is what the browser is displaying to screen readers and other accessibility software and uses the behaviour of the HTML elements along with the ARIA roles/states/properties defined by the webpage to construct that tree. Thus, it will display an ol/ul as a `role=list` unless overridden to be e.g. a `tablist` by the website.

See https://www.w3.org/TR/wai-aria-implementation/ for a specification on how browsers should implement HTML and ARIA to different operating system accessibility APIs.

See https://www.w3.org/WAI/ARIA/apg/patterns/ for a guide on how to create accessible markup for custom controls and the associated examples.

See specifically https://www.w3.org/WAI/ARIA/apg/practices/names-and-descript... for details on naming. That has extensive notes and details for labeling elements correctly.

See https://getbootstrap.com/docs/5.0/components/ for bootstrap markup on creating accessible components.

There are plenty of other resources.

IIRC, libraries like numpy and pytorch can already do that as they store the matrices as 1D arrays with information on things like the stride length (advancing to the next row). That allows you to implement operations like transposition by editing the stride length and other parameters without manipulating the content of the matrix array.

That goes back to Ken Thompson's NFA regex interpreter from 1968 [1], [2], [3]. Note: that whole regex series by Russ Cox [4] is great.

[1] https://dl.acm.org/doi/10.1145/363347.363387 -- Programming Techniques: Regular expression search algorithm

[2] https://swtch.com/~rsc/regexp/regexp1.html -- Regular Expression Matching Can Be Simple And Fast

[3] https://swtch.com/~rsc/regexp/regexp2.html -- Regular Expression Matching: the Virtual Machine Approach

[4] https://swtch.com/~rsc/regexp/ -- Implementing Regular Expressions

From the video [1] that links to Ben Eater's fork with extensions and configuration specific to his 6502 breadboard computer [2]. That in turn is forked from `mist64/msbasic` which refers to a blog post [3] which states:

> This episode of “Computer Archeology” is about reverse engineering eight different versions of Microsoft BASIC 6502 (Commodore, AppleSoft etc.), ...

> This article also presents a set of assembly source files that can be made to compile into a byte exact copy of seven different versions of Microsoft BASIC, and lets you even create your own version.

So Ben Eater's version is based on a reverse engineered version of the same program. You should be able to adapt the code released here to run on Ben Eater's 6502 with a bit of work.

[1] https://www.youtube.com/watch?v=XlbPnihCM0E&list=PLowKtXNTBy...

[2] https://github.com/beneater/msbasic

[3] https://www.pagetable.com/?p=46

Ben Eater's 6502 series [1] uses MSBASIC for programming along with WozMon as the terminal interface.

[1] https://www.youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXN...

A better formulation would be something like Fuzzy Logic [1]. That represents floating point values from 0 (false) to 1 (true), so 0.5 could be "unsure", 0.9 could be "very likely", etc. However, that doesn't make boolean logic invalid.

Boolean logic is also the foundation of computing: logic gates, circuits like BCD, etc.

[1] https://en.wikipedia.org/wiki/Fuzzy_logic

> First, the discussion is about about news, not science (nor about general LLM behaviour).

What if science is the news, such as:

1. advancements in fusion power; or

2. progress/status of the Artemis missions; or

3. new LLM models and/or capabilities (e.g. Project Glasswing).

With things like that you typically have a press announcement/briefing, a research paper/publication, or both. That information is then presented in newspapers/media that may obscure, misrepresent, or overly generalize the original finding/announcement.

There may also be clarifications, retractions, etc. after publication, such as with the initial announcement/publication of the proof to Fermat's Last Theorem that initially had an error that was later corrected.

That doesn't work if you have limited or no connectivity (e.g. on a mountain range). There are also privacy concerns, e.g. a doctor using it to transcribe medical information.

It's useful to be able to run models/code on the CPU or split between CPU and GPU, especially for models that cannot fit into the GPU's VRAM, if you are running multiple models, or if you have training data that you need to move between CPU and GPU.

How are ARIA roles/attributes bad for accessibility?

Sure, if there is a HTML element that works then use it, but not every UX pattern is expressible in HTML without specifying roles/attributes (e.g. tabs [1]) and not all browsers support recent HTML elements/attributes (such as using details/summary for accordions).

ARIA patterns [2] has a list of examples for UX components and their examples specify/use ARIA roles/attributes.

[1] https://www.w3.org/WAI/ARIA/apg/patterns/tabs/

[2] https://www.w3.org/WAI/ARIA/apg/patterns/

Python has type annotations now [1] that type checkers, IDEs, etc. can use.

[1] https://docs.python.org/3/library/typing.htmlhttps://docs.py...

Locally, I'm using gitolite+cgit. I was previously using Gitea, but that didn't suit my requirements.

I'm using GitHub for my open source projects as:

1. While GitHub Actions has its issues and doesn't work for everyone, I've found it easy to build and test an IntelliJ plugin against multiple IntelliJ versions.

2. I don't have to pay for and manage the hosting of the git repository.

Special Relativity is an extension of Galilean/Newtonian mechanics (motion of projectiles and other objects) to the case where the object is travelling at speeds that are a fraction of the speed of light. It deals with non-accelerating frames of reference. Satelites need to use this to correct for time dilation effects, but tracking the trajectory of an arrow/etc. or a car/etc. travelling from one location to another then classical mechanics is sufficient.

General Relativity is an extension of Newtonian gravity. It is also an extension of Special Relativity to cover accelerating frames of reference. Satelites need to use this, as does tracking the orbit of Mercury. However, for the orbits of other planets and the moon, using Newtonian gravity is sufficient for a reasonable degree of accuracy, and is used for tracking things like equinoxes/solstices, full moons, etc..

Blink is derived from WebKit, so is in the same family like the other Blink/WebKit derived browsers. Fireox/Gecko is a different browser implementation.

There are a few YouTube "can I solve [story] before the reveal?" style videos focusing on Agatha Christie novels ranging from around 4 years old to today.

My experience is that at Q5 and lower you start to see noticeable degredation in performance/quality. It's especially noticeable at Q4 where models will easily get trapped in repeating token loops. I generally use Q6.

[1] https://medium.com/@paul.ilvez/demystifying-llm-quantization...

The comment in parenthesis mentions "they're not derived from a probability space" [1]. I don't know about probability spaces nor softmax to know what part of a probability space this is missing compared to other probability distributions, nor how other probability distributions satisfy probability spaces.

[1] https://en.wikipedia.org/wiki/Probability_space

The repository names all look like two terms/words from dune (harkonen, mentat, ornithoptor, etc.) followed by a number. This would indicate that the account (possibly GitHub auth/actions token) has been compromised and then used to create the repository.

What's the usecase for this API?

My experience with running LLMs locally is spinnnig up llama-server (possibly on a separate machine) and then configuring other applications to point to that OpenAI compatible web server instead of OpenAI or similar.

I don't want a web browser creating/running an LLM instance as that machine may not have the capability or capacity to run an LLM instance.

I used Gitea for a while, but eventually switched to gitolite+cgit. That was down to the org/repo structure not fitting my git hierarchy (I'm using a topic/repo, topic/subtopic/repo style structure) and the lack of organization/topic wide issue tracking/management.

If you want a GitHub-like UI (with org/repo structure limitations) use either Forgejo or Gitea.

If you want a similar but different experience use GitLab.

If you want something more akin to the kernel experience (i.e. hosting, flexible repository structure, user auth via ssh keys, and a simple web UI) use gitolite with cgit, or alternatively gitweb.

One challenge is that model evaluation is typically domain/application specific. Model performance can also depend on the system prompt and the input/context.

Regarding evaluation, I've found using tools like promptfoo (and in some cases custom tools built on top of that) are useful. These help when evaluating new models/versions and when modifying the system prompt to guide the model. Especially if you can define visualizations and assertions to accurately test what you are trying to achieve.

This can be difficult for tasks like summarization, code generation, or creative writing that don't have clear answers. Though having some basic evaluation metrics and test cases can still be useful, and being able to easily do side-by-side comparisons by hand.

Some relevant links:

[1] https://www.npr.org/2026/04/11/nx-s1-5778508/anthropic-proje...

> Improvement in AI models' capabilities became noticeable early 2026, said Daniel Stenberg.

> He estimates that about 1 in 10 of the reports are security vulnerabilities, the rest are mostly real bugs. Just three months into 2026, the cURL team Stenberg leads has found and fixed more vulnerabilities than each of the previous two years.

[2] https://www.linkedin.com/posts/danielstenberg_curl-activity-...

> The new #curl, AI, security reality shown with some graphs. Part of my work-in-progress presentation at foss-north on April 28.

So it's similar to Defence of the Ancients that resulted in DotA and other MOBAs. It wonder if they'll be able to create a version of this with the new mechanics/gameplay loop but with different art/assets.

The Q5 quantization (26.6GB) should easily run on a 32GB 5090. The Q4 (22.4GB) should fit on a 24GB 4090, but you may need to drop it down to Q3 (16.8GB) when factoring in the context.

You can also run those on smaller cards by configuring the number of layers on the GPU. That should allow you to run the Q4/Q5 version on a 4090, or on older cards.

You could also run it entirely on the CPU/in RAM if you have 32GB (or ideally 64GB) of RAM.

The more you run in RAM the slower the inference.

Tools like this (formal verification, sparse, etc.) and built-in mechanism (types, generics, RAII, rust's borrow checker) can only verify issues within the scope of that framework. There are also trade-offs and limitations with each type and each implementation.

Type checking allows you to (outside of type casting such as in languages like C/C++ and casting to object for generic containers in Java) verify that an object is of a given type. That allows you to be sure that a well-formed program isn't doing things like putting a random object in a list.

Languages like C#, Scala, and Kotlin improve Java generics by making the generic type of a container or other interface/type part of the type system. This allows generic types of a generic type to preserve the inner type. This makes it possible to implement things like monads and mapping functions to preserve the generic type.

A similar thing is possible with union types, sealed interfaces/traits, etc. that allow you to check and verify the return type instead of defaulting it to a generic object/any type.

Likewise with other features like nullable/non-null annotations (or corresponding nullable type annotations like in Kotlin and recent C# versions).

All of these can be abused/circumvented, but if you keep your code within that framework the compiler will stop that code compiling. Likewise, these solve a limited set of bugs. For example, nullable types can't verify memory management and related bugs.

My only gripe with the game is that healing doesn't give XP to the healing units. This means you need to place them in combat to level up instead of placing them behind the fighters like they are intended to be, and with them initially having low health they are very squishy. I know you can kinda cheese it by reducing a monster to 1-2 HP and then getting them to attack, but it feels like going against their role.