skysight-inc/HackerNews huggingface dataset:
That's a very unusual use case. When one of my airtags is in my building I can locate it with ~0.1ft precision using UWB. No matter how many other iPhones are in the building I can't get <100ft precision without UWB.

The difference between "airtag is in under the top left corner of the couch cushion" and "airtag might be in the same building as you" is so large that I wonder why you don't get a old used iPhone and swap the battery to create a functional phone.
You can do this with a monolith architecture as others point out. It always comes down to governance. With monoliths you risk slowing yourself down in a huge mess of SOLID, DRY and other “clean code” nonsense which means nobody can change anything without it breaking something. Not because any of the OOP principles are wrong on face value, but because they are so extremely vague that nobody ever gets them right. It’s always hilarious to watch Uncle Bob dismiss any criticism with a “they misunderstood the principles” because he’s always completely right. Maybe the principles are just bad when so many people get them wrong? Anyway, microservices don’t protect you from poor governance it just shows up as different problems. I would argue that it’s both extremely easy and common to build a bunch of micro services where nobody knows what effect a change has on others. It comes down to team management, and this is where our industry sucks the most in my experience. It’ll be better once the newer generations of “Team Topologies” enter, but it’ll be a struggle for decades to come if it’ll ever really end. Often it’s completely out of the hands of whatever digitalisation department you have because the organisation views any “IT” as a cost center and never requests things in a way that can be incorporated in any sort of SWE best practice process.

One of the reasons I like Go as a general purpose language is that it often leads to code bases which are easy to change by its simplicity by design. I’ve seen an online bank and a couple of landlord systems (sorry I can’t find the English word for asset and tenant management in a single platform) explode in growth. Largely because switching to Go has made it possible for them to actually deliver what the business needs. Mean while their competition remains stuck with unruly Java or C# code bases where they may be capable of rolling out buggy additions every half year if their organisation is lucky. Which has nothing to do with Go, Java or C# by the way, it has to do with old fashioned OOP architecture and design being way too easy to fuck up. In one shop I worked they had over a thousand C# interfaces which were never consumed by more than one class… Every single one of their tens of thousands of interfaces was in the same folder and namespace… good luck finding the one you need. You could do that with Go, or any language, but chances are you won’t do it if you’re not rolling with one of those older OOP clean code languages. Not doing it with especially C# is harder because abstraction by default is such an ingrained part of the culture around it.

Personally I have a secret affection for Python shops because they are always fast to deliver and terrible in the code. Love it!
Two theories:

1) This is an ego problem. Whoever is doing the development cannot handle being called out on certain software architecture / coding mistakes, so it becomes "nitpicking".

2) The software shop has a "ship out faster, cut corners" culture, which at that point might as well turn off the AI review bot.
CodeMic: A new way to talk about code
> How many "Guesses" is it self generating and internally validating

That's completely fair game. That's just search.
Having read through that, there is zero chance you could actually violate that doing any sort of reasonable or normal construction.

Or do you have an example where someone built a house in a reasonable fashion, an eagle ran into it, and the owner or construction company was charged?

You’d have to build right next to an active nest, or intentionally design the building to be a hazard in an area they were nesting/living. Which goes to my comment.
Recording all of your SSL-decrypted network logs and reconstructing them later is one step further. I'm sure there's a chain of custody issue not much further.

But what I like about SingleFile is that printing the SingleFile page tends to print to PDF better than an actual dynamic page (annoying modals etc show up in the print that are not normally visible). I have a python service running that organizes my SingleFile html files into folders by each domain and stored my google drive.

It's like a confused mix of wget's -x directories and a postscript printer so you can avoid chrome's print to skia pdf pipeline until a brighter day.
/!\ this is just my perspective /!\

> would love to know why leaving it unbounded was decided upon. Might be I don't quite grok the culture of F#.

You may look at more context in the discussions pertaining to the RFC: https://github.com/fsharp/fslang-design/blob/main/FSharp-4.1...

I think those are the main factors:

* "Keep It Simple Stupid" principle

* community pressure so that F# libraries could standardise on better things that Choice1Of2 = Ok and Choice2Of2 = Error, or using a bare tuple (which is very not clean for APIs)

* F# ought to remain flexible in terms of not pretending of totally abstracting away the fact that most of the dotnet base class library or the overall dotnet ecosystem, uses exceptions, it is not like Result type was created to abstract runtime exceptions away.

For all other needs, one is just one wrapper / or abstraction (for library that don't "meet our standards" in terms of exception safety) away, along with a bit of adhoc tooling around leveraging FSharp.Compiler.Service for sake of adding static analysis, for architecture astronauts, dealing with behemoth or safety critical codebases, requiring even more screws turned, but even there, F# (and so many other languages) may not meet the bar if those are the critical properties for a project involving code.

Overall, F# is just pragmatic for the 99.99%, and not trying too hard beside the steady core language idioms, and how the organic community wants it over time, to satisfy hypothetical and intellectual pursuits of the highest abstraction and safety.

The culture of F# is mostly about throwing productivity parties and being done with it (while not suffering so many of the wrong choices done by C, C++, Java and it's famed sibbling, C#), rather than the higher conceptual type theory perfection that (sometimes ?) lead to code that is not less kludgy, or easier to maintain, in the grand scheme, for the masses of developers, that are not yet expert in Haskell, Scala, etc.

It is probably not too dissimilar to OCaml culture, while embracing some aspects that are familiar to more people, due to relationship with dotnet ecosystem.
I'm at the point of learning German that it's starting to get interesting.

One thing is that when you begin a sentence, to get the grammar correct sometimes you need to know what comes at the end of the sentence, along with understanding the context in which nouns are used.

For example "the blue dog". In German if you said "I pat the blue dog" it would actually change to something like "I pat then bluen dog", whereas "I am the blue dog" wouldn't have the "-n" endings on the word "the" and "blue".

Once you change the word "dog" for "cat" then the endings on the words "the" and "blue" change, because every noun in German has a different gender (masculine, feminine, neuter), and the words endings in a sentence can change based on the particular gender and context they're used in.

Anyway, this is a long way of saying - you need to know what you're talking about BEFORE you begin!

In English we have the luxury of kind of making it up as we go. If we decide last minute that we're not patting a blue dog, but are patting a blue cat then that's simple, we just change the noun at the end once we get to it. In German you need to have that noun info upfront, otherwise you might not get the grammar correct!
I must be not quite following your explanation...
In most of the EU, there are multi-party systems. From what I can tell, that is because of multi-member districts. Eg. The Netherlands has only one district for parliamentary elections (150 seats). There are more than 2 parties in Parliament there.
It really doesn’t see itself, generative AI is not aware.
If you think of the "AI" benefit as more of a linter then the value starts to become clear.

E.g., I've never hesitated to add a linting rule requiring `except Exception:` in lieu of `except:` in Python, since the latter is very rarely required (so the necessary incantations to silence the linter are cheap on average) and since the former is almost always a bug prone to making shutdown/iteration/etc harder than they should be. When I add that rule at new companies, ~90% of the violations are latent bugs.

AI has the potential to (though I haven't seen it work well yet in this capacity) lint most such problematic patterns. In an ideal world, it'd even have the local context to know that, e.g., since you're handling a DB transaction and immediately re-throwing the raw `except:` is appropriate and not even flag it in the "review" (the AI linting), reducing the false positive rate. You'd still want a human review, but you could avoid bugging a human till the code is worth reviewing, or you could let the human focus on things that matter instead of harping on your use of low-level atomic fences yet again. AI has potential to improve the transition from "code complete" to "shipped and working."
Stupid sexy harmonics.
Interesting. Yeah, being able to use Arm flags always is probably a big thing, since they even added hardware support for that.

It's a huge achievement for a single person to have written most of that.
Surely you can register your collection with the local institutions somehow, so that they’ll at least be aware of your travels?

I’ve had the same thought with my own dispersal of extremely minor stuff I’ve found out in the wilderness - every time I brought home a nautilus shell from some other part of the state, or a skull of some critter I found interesting in my youth, I had the idea “maybe someone will think of this as a fossil at some point in the vast future, and wonder how it got there..”
True, I guess you're right.
Its merged into CPython 3.13 but labeled as experimental.

Single threaded cpu bound workloads suffer in benchmarks (vs i/o workloads) till they put back the specializing adaptive interpreter (PEP 659) in 3.14. Docs say a 40% hit now, target is 10% at next release.

C extensions will have to be re-built and ported to support free threaded mode.

Some interesting and impactful bits of open source work for those with a c++ multithreading background.
Ah yes, the most reliable solution to a wrong choice of a data structure: add data-specific hacks until it works. For the life of me I can't figure out why people never consider replacing linked lists. Even without worst-case O(n) insertion, they usually behave worse than vectors, deques, or hives.
I can't stop thinking this is how we will save humanity from the internet.

Who needs to use the internet when you can have an agent do it for you? And once it is filled with agents, what will be the point of using it?
https://archive.is/gTR6k
Co-Adapting Human Interfaces and LMs
Sucks that generations of people going forward will never know a pure human internet.

It seems like the internet of the 90s to 2010s was forever a special moment in history. Destined to be short lived.
Listing all mounts in all mount namespaces
This will be our Tower of Babel moment.
It's still in production (until 2025.)
The F-15, F-16, and F/A-18 have all been continuously upgraded over time. Examples:

https://www.defensenews.com/air/2024/04/12/air-force-to-get-...

https://theaviationist.com/2024/01/24/usaf-to-fly-f-16s-into...

https://www.twz.com/litening-targeting-pod-tested-on-f-a-18-...
RAG Logger: An Open-Source Alternative to LangSmith
Hey HN,
I built RAG Logger, a lightweight open-source logging tool specifically designed for Retrieval-Augmented Generation (RAG) applications. LangSmith is excellent, but my usage is quite minimal, and I would prefer a locally hosted version that is easy to customize.
Key features:
Detailed step-by-step pipeline tracking
Performance monitoring (embedding, retrieval, LLM generation)
Structured JSON logs with timing and metadata
Zero external dependencies
Easy integration with existing RAG systems
The tool helps debug RAG applications by tracking query understanding, embedding generation, document retrieval, and LLM responses. Each step is timed and logged with relevant metadata.
This thing should be a poster example of premature optimization. Sure you can squeeze a few milliseconds out in a performance critical task. Most things won't measurably benefit though, while making all handling super awkward.

If your abstract domain description is fundamentally a collection of things that have a few parts each, then have your data type represent that, instead of turning it inside out for cache effects. If those become relevant at some point, try to abstract that away and do the optimized internal representation under the hood. But don't preemptively design your data structures in a cumbersome way just in case. That's bad advice.
Hey HN, I built RAG Logger, a lightweight open-source logging tool specifically designed for Retrieval-Augmented Generation (RAG) applications.

LangSmith is excellent, but my usage is quite minimal, and I would prefer a locally hosted version that is easy to customize.
Key features:

Detailed step-by-step pipeline tracking

Performance monitoring (embedding, retrieval, LLM generation)

Structured JSON logs with timing and metadata

Zero external dependencies

Easy integration with existing RAG systems
sorry to hijack the discussion but do you see any chance of consolidating the theoretical framework of real numbers with practical calculations of floats?
That is if I proof the correctness of some theorem for real numbers ideally I would just use that as the algorithm to compute things with floats.

also I was shocked to learn that the simple general comparison of (the equality of) two real numbers is not decidable, which is very logical if you think about it but an enormous hindrance for practical applications. Is there any work around for that?
I mean, it's harder to read compared to normal text with spaces and punctuation.
I think unfortunately the conclusion here is a bit backwards; de-risking deployments by improving testing and organisational properties is important, but is not the only approach that works.

The author notes that there appears to be a fixed number of changes per deployment and that it is hard to increase - I think the 'Reversie Thinkie' here (as the author puts it) is actually to decrease the number of changes per deployment.

The reason those meetings exist is because of risk! The more changes in a deployment, the higher the risk that one of them is going to introduce a bug or operational issue. By deploying small changes often, you get deliver value much sooner and fail smaller.

Combine this with techniques such as canarying and gradual rollout, and you enter a world where deployments are no longer flipping a switch and either breaking or not breaking - you get to turn outages into degradations.

This approach is corroborated by the DORA research[0], and covered well in Accelerate[1]. It also features centrally in The Phoenix Project[2] and its spiritual ancestor, The Goal[3].

[0] https://dora.dev/

[1] https://www.amazon.co.uk/Accelerate-Software-Performing-Tech...

[2] https://www.amazon.co.uk/Phoenix-Project-Helping-Business-An...

[3] https://www.amazon.co.uk/Goal-Process-Ongoing-Improvement/dp...
A solar panel + battery + laptop would make for cheap local AI. I assume we will have efficient LLM inference chips in a few years, and they will be a commodity.
And would they start killing themselves, first as random "AI agents hordes" and then, as time progresses, as "AI agents nations"?

This is a rhetorical question only by half, my point being that no AGI/AI could ever be considered as a real human unless it manages to "copy" our biggest characteristics, and conflict/war is a big characteristic of ours, to say nothing about aggregation by groups (from hordes to nations).
Why we use our own hardware
The main issue with this “output focused” approach is, which is what the Turing test basically is, is that it’s ignorant of how these things actually exist in the world. Human beings can easily be evaluated and identified as humans by various biological markers that an AI / robot won’t be able to mimic for decades, centuries, if ever.

It will be comparatively easy to implement a system where humans have to verify their humanity in order to post on social media/be labeled as not-AI. The alternative is that a whole lot of corporations let their markets be overrun with AI slop. I wouldn’t count on them standing by and letting that happen.
This is the level of projects that our GIS students deliver at the end of 60 hours of non-mandatory class. Perhaps 70%+ of visitors of HN can do it if they decide to, it is just an interdisciplinary area that not many explore. A project of similar complexity in the WEB or ML are would never get upvoted so much.
Probably both, the even older F-15s are still the main workhorse fighter for US and others albeit with many upgrades
And then we got something which is equally unusable on a touchscreen as it is with a keyboard and mouse.
[citation needed].

ARPANET was not the only network in existence, even then. Networks existed in various forms. Later, BBSes existed. My guess is sooner or later there would have been something (probably more than one, even) our current internet, but we would never know. Would it look worse or balkanized or proprietary, my guess would be yes, I give you that, but we'll never know that either.

(I originally noted in my topmost post minimal, surgical, involvement is the aspiration, not necessarily zero, but I digress.)
Guardian is not much different than the Sun, Der Spiegel or Foxnews these days. Dont read it or take it with a grain of salt.
> LLMs lack any "inner life" and that by ignoring this aspect of what makes us human we've really moved the goalposts on what counts as AGI

Maybe it's just a response style, like the QwQ stream of consciousness one. We are forcing LLMs to give direct answers with a few reasoning steps, but we could give larger budget for inner deliberations.
I don’t think we humans choose. I am a deterministic and seeing all collective and individual choices as force of nature.

Will indeed read more Dawkins. It’s always a pleasure.
DIY – UniFi Security Surveillance System Setup
It has wheels like a truck, a seat for the driver, a steering wheel, and two pedals, but a go-kart is much different from a truck.

Similarly, a "neural network" for an LLM is much different from the human brain and nervous system, plus all of the other systems that work alongside and affect it.

The danger is not that the AI is elevated to that of a human by the "they're so similar" reasoning, the danger is that the average human will be degraded to AI-level status and not thought of as anything but a tool.
Typing 305WPM for 15 seconds [video]
I'd take 8 hours on a train where I can relax, read a book or do some work over 9 hours driving.
You do not gotta hand it to the Houthis, who are themselves genocidal.
Not sure what you mean by “good”, it’s just going to happen.

We could have developed like trees and plants or mushrooms, with no brain and less pain, perhaps, and keep our DNA moving along forward. But it happened to be that way.
You can use floats to accelerate interval arithmetic (which is "exact" in the sense of constructive real numbers) but that requires setting the correct rounding modes, and being aware of quirks in existing hardware floating point implementations, some of which may e.g. introduce non-exact outputs in several of the least significant digits, or even flush "small" (for unclear definitions of "small", not always restricted to FP-denormal numbers) results to zero.

Equality is not computable in the general case, but apartness can be stated exactly. For some practical cases, one may also be able to prove that two real numbers are indeed equal.
F3 - (Fast Furious Fail-Safe)
It's not the plane, Mav. It's the pilot.
> any new knowledge being acquired now comes from humanity+AI

AI is an experience flywheel, it serves many people and learns from many people. It elicits our tacit experience and captures our reactions as it works through tasks. I see this as the primary way experience will spread in the future (distributed population generated tasks -> centralized experience in LLM -> distributed contextual application). It's like auto-open sourcing our problem solving as we solve problems.
Your insights please?
Can you share the big problems in outsourcing app development, that you've come across that no one is talking about? Second, have you searched for comprehensive answers to big questions and not been able to find a good, comprehensive answer available that you're willing to share?
There's a lot hanging on what you mean by deliberate thought here. I'll just label whatever you mean X

I presume you are claiming by saying orthogonal that statistics are neither required nor preclude X.

You are using the presence of statistical processes as a claim against ChatGPT with

>It's a derivative of that being thrown back at you via statistics.

For this to have any weight given the orthogonal claim, you are asserting that LLMs are entirely statistics (the property you assert is orthogonal and thus carries no weight, yet invoking it as a property suggests that it is relevant, presumably because there are no other properties)

Then we get into the weeds of what you mean by statistics. It could be broad or narrow. If it is narrow then it is easy to claim neither sufficient nor precluding, but extremely hard to draw any other conclusion because any system can break free of the proof by including the tiniest bit that does not fit within the narrow definition of statistics. If the definition is broader to include everything that happens within ChatGPT, then you are faced with the question of what is not covered by that definition of statistics. How can you show that human minds do not operate within those limitations.

I don't think that ChatGPT is conscious in any sense that would be meaningful to a layman, but I also don't think that you can demonstrate it could not be purely based on the fact it uses any particular process without a rigorous proof of the limitations of that process.

The only way you could reasonably
But isn't that the point? If someone is fine eating something so long as he is ignorant or naive, doesn't that point to a detachment from reality?
Container sizes may be affected though.
The Surprising Way Credit Cards Make Money [video]
Another application is Ambisonic sound spatialisation formats, where a finite set of signals corresponding to spherical harmonics are used to encode spatial sound fields. https://en.wikipedia.org/wiki/Ambisonics
Good insight.

Ah... category theory :-)

Array-of-Stuct (AoS) treats order in arrays as meaningful, arrays as lists, so AoS => Struct-of-Array (SoA) doesn't loose information. It is a sound transformation because it is a homomorphism.

Some languages (homoiconic, or with macros or template support) can express this code transformation: e.g. Julia, https://github.com/JuliaArrays/StructArrays.jl, or Rust, https://www.abubalay.com/blog/2019/02/16/struct-of-arrays

In a sense, you can see this transformation through the concept of monads (although Haskell monads or F# computational expressions cannot directly express it, as far as I know). Then the corresponding category diagrams leads to sets or multi-sets (run-length encoding requires or implies some concept of identity, so unordered lists with repetitions = bags and multi-sets are equivalent in this specific context), as the right concept for Enums of Arrays.