skysight-inc/HackerNews huggingface dataset:
Yeah, though I do wonder for a big model like 405B if the original training recipe, really matters for where models are heading, practically speaking which is smaller and more specific?

I imagine its main use would be to train other models by distilling them down with LoRA/Quantization etc(assuming we have a tokenizer). Or use them to generate training data for smaller models directly.

But, I do think there is always a way to share without disclosing too many specifics, like this[1] lecture from this year's spring course at Stanford. You can always say, for example:

- The most common technique for filtering was using voting LLMs (without disclosing said llms or quantity of data).

- We built on top of a filtering technique for removing poor code using ____ by ____ authors (without disclosing or handwaving how you exactly filtered, but saying that you had to filter).

- We mixed certain proportion of this data with that data to make it better (without saying what proportion)

[1] https://www.youtube.com/watch?v=jm2hyJLFfN8&list=PLoROMvodv4...
The more correct statement is "you never pay more in taxes by moving up a bracket" - though even that is not correct in all cases.

There are a lot of things (IETC for example, or benefits, or health insurance) which have $ cutoffs. Or tax breaks (i.e. electric vehicle credit) that only apply below a certain income. Exceeding those fixed points can certainly make you make less money.

One thing I ran into recently was fiscal incentives for homeownership (though not directly related to taxes) - there is a cutoff at a certain income level where if you stay below it you get a $10K credit towards closing costs. The tax code is full of things like that.
If your certificate has been revoked and you don't know that (e.g. from a very alarming e-mail), something has seriously gone wrong. In the general case, it'd be yourself requesting the revocation to begin with. But even if it isn't, I'm pretty sure the CA is supposed to tell you expeditiously.
The weights are a transformed, lossy and non-complete permutation of the training material. You cannot recover most of the dataset reliably, which is what stops it from being an outright replacement for the work it's trained on.

> does not mean that you are not distributing them.

Except you literally aren't distributing them. It's like accusing me of pirating a movie because I sent a screenshot or a scene description to my friend.

> It's scary to think that "training" is becoming a thinly veiled way to strip copyright of works.

This is the way it's been for years. Google is given Fair Use for redistributing incomplete parts of copywritten text materials verbatim, since their application is transformative: https://en.wikipedia.org/wiki/Authors_Guild,_Inc._v._Google,....

Or Corellium, who won their case to use copywritten Apple code in novel and transformative ways: https://www.forbes.com/sites/thomasbrewster/2023/12/14/apple...

Copyright has always been a limited power.
The way I see it, there are a limited number of ways that a bare-metal component with no heap can "catastrophically fail":

1. "Undefined behavior" due to typical memory bugs: code written in 100% safe Rust cannot trigger this behavior.

2. "Undefined behavior" due to a stack overflow: this can happen in safe Rust, but you can provably guard against it by banning recursion and dynamic dispatch, and doing static stack depth analysis on your program.

3. Panic/abort: naively written bare-metal Rust typically has many potential calls to panic!() due to bounds checks, integer overflows, .unwrap(), etc, and if these get called the system will typically fail catastrophically. I like to solve this by having CI fail if the optimized binary contains ANY call-sites to the panic handler. This forces the developer to handle these edge cases with idiomatic error handling before they can merge their code (but can cause some development pain/brittleness when the optimizer heuristics change).

4. Infinite loops: in most bare metal systems, if a section of code doesn't complete within some reasonable time, a watchdog will fire and the system will crash. Ideally there would be some static analysis that could tell me whether some particular code is capable of exceeding the allotted time bounds, but I'm not aware of such tooling, and need to resort to hacky solutions such as fuzzing and handling resets "gracefully" at runtime.
I've always been somewhat flexible, especially when traveling, but I've pretty much never worked super-long days as a routine.
I'd like to think it's become ubiquitous - it has been a while since I've seen a signal without a red clearance configured.

However, the Federal Highway Administration in the US (which sets guidelines, but most states define actual rules at the state level) still says in their Signal Timing Manual [1]

> The use of a red clearance interval is optional, and there is no consensus on its application or duration. [...] there may not be safety benefits associated with increased red clearance intervals.

and goes on to describe how it has negative traffic flow implications.

so I suspect at least some agencies out there still are not using them.

[1]: https://ops.fhwa.dot.gov/publications/fhwahop08024/chapter5....
Condé Nast has reportedly accused AI search startup Perplexity of plagiarism
Maybe Musk's taking cues from XKCD: https://xkcd.com/1897/

That said, of course it does. If Twitter sucks, then it is reasonable to assume any particular aspect of Twitter also sucks.
https://openrouter.ai/models/meta-llama/llama-3.1-405b-instr...
It's true that there are valid programs which don't type check in the same way that for any mathematical system there are truths which can't be proven.

In practice though, almost any program you'd want to write can be type checked, in the same way that few proofs get tied into Gödelian knots.
JavaScript has async/await because it solves a very specifically JavaScript problem: the language has no threads and all your code lives in the main event loop of the browser tab. If you do the normal thing of pausing your JavaScript until an I/O operation returns, the browser hangs. So you need to write everything with callbacks (continuation passing style), which is a pain in the ass and breaks exception handling. Promises were introduced to fix exceptions and async/await introduced to sugar over CPS.

There's also a very specifically Not JavaScript problem (that happens to also show up in Node.js): exotic concurrency scenarios involving lots of high-latency I/O (read: network sockets). OS kernel/CRT[0] threads are a lot more performant than they used to be but they still require bookkeeping that an application might not need and usually allocate a default stack size that's way too high. There's no language I know of where you can ask for the maximum stack size of a function[1] and then use that to allocate a stack. But if you structure your program as callbacks then you can share one stack allocation across multiple threads and heap-allocate everything that needs to live between yield points.

You can do exotic concurrency without exposing async to the language. For example, Go uses (or at least one point it did) its own thread management and variable-size stacks. This is more invasive to a program than adopting precise garbage collection and requires deep language support[3]. Yes, even moreso than async/await, which just requires the compiler transform imperative code into a state machine on an opt-in basis. You'd never, ever see, say, Rust implement transparent green threading[2].

To be clear, all UI code has to live in an event loop. Any code that lives in that event loop has to be async or the event loop stops servicing user input. But async code doesn't infect UI code in any other language because you can use threads and blocking executors[4] as boundaries between the sync and async worlds. The threading story in JavaScript doesn't exist, it has workers instead. And while workers use threads internally, the structured clone that is done to pass data between workers makes workers a lot more like processes than threads in terms of developer experience.

[0] Critical Runtime Theory: every system call is political

[1] ActionScript 3 had facilities for declaring a stack size limit but I don't think you could get that from the runtime.

async/await syntax in Rust also just so happens to generate an anonymous type whose size is the maximum memory usage of the function across yield points, since Rust promises also store the state of the async function when it's yielded. Yes, this also means recursive yields are forbidden, at least not without strategic use of `Box`. And it also does not cover sync stack usage while a function is being polled.

[2] I say this knowing full well that alpha Rust had transparent green threading.

[3] No, setjmp/longjmp does not count.

[4] i.e. when calling async promise code from sync blocking functions, just sleep the current thread or poll/spinwait until the promise resolves
Yea, I don't want to oversell it. The restic FUSE mount isn't anywhere near "native" performance. But, it's fast enough that if you can narrow your search to a directory, and if you're using a local restic repo, using grep and similar tools is do-able. To me, using `restic mount` over a USB3 SSD repo makes the mount folder feel sorta like a USB2 filesystem rather than a USB3 one.
But not Palantir? Damn.
Meta Llama 3.1 405B
I'm interested in both, but quickly finding the nearest gaps of at least duration X is most important.
Is there any reason I would deliberately purchase one of these over a standard 32GB drive? Trying to think of if there’s a case where I would want to trick some hardware into thinking it has a 2TB drive when it really doesn’t?
> What is the equivalent of the training data for something like the Linux kernel?

It's the source code.

For the linux kernel:

compile(sourcecode) = binary

For llama:

train(data) = weights
Async/await is just a sugar that many people happened to like.

As for me, I like Go's CSP better.
Yes, you can finetune Llama: https://llama.meta.com/docs/how-to-guides/fine-tuning/
For small short-lived scripts the compilation (in any native form) time may be much bigger than bytecode execution time. And if a platform does not support dynamic code generation the end result is non-functional code or interpreter inside interpreter for LINQ expressions (as they can still run as interpreted, at least they try). See a comment in Jint readme about that.

I tried to compare some script languages implemented in C# with Roslyn script compilation. Same code to sum up 1M doubles. Roslyn takes almost 100ms to compile the code.

This may become especially painful when source code changes on every execution and reusing compilation result is not possible for some reason, e.g. user input or parametrized string template.
Well, at first it only showed up as 2 TB, which was at least possible though unlikely. But f3 indicated it was faking 10, at which point I realized it was presenting several additional partitions that were so corrupted the OS wasn’t even making them available to mount. After that I opened it just to see what was inside.
Sunday Was Earth's Hottest Day on Record
Microsoft says 8.5M systems hit by CrowdStrike BSOD, releases USB recovery tool
For regular webserver users, accessed by web browsers, no changes are needed.

Note this is probably at least a year, if not more, away.

I'm sorry this post wasn't accessible enough, and we'll have more communications in the coming years as this gets closer.

(I work at Let's Encrypt and proofread this post before publishing)
And how, exactly, does one "learn" that?

To me it's always been a matter of personality. As an introvert, I can't picture myself doing the kinds of social interactions required to sell a business on my own.
I like the formulation of 'the amount of information we don't know about a system that we could in theory learn'. I'm surprised there's no mention of the Copenhagen interpretation's interaction with this definition, under a lot of QM theories 'unavailable information' is different from available information.
And the job description was: "Are you completely unoriginal? Do you copy others? Then we have a job for you!"
Nothing will change for you, and nothing will break. The point of this post is to give a maximum-lead-time heads-up to the folks who _do_ need to care (the folks writing revocation-checking code in clients) so that later, more specific announcements don't come as a surprise.
Paper and something to draw with - like a pencil, pen, or marker - is the simplest thing that might work. Maybe splurge on a scale if you need accurate plans and a compass if the wheels you draw need to be round.

[Caveat: I'm assuming you actually want custom bikes and not custom designs (assuming that the goal is to make bikes and not plans or models) and I believe that the best way to start building bikes is building bikes not learning to use software. YMMV. Good luck.]
Works perfectly fine for me. v125.3.0 with uBlock.
isn't that just inflation with extra steps?
> I don't think not releasing the commit history of a project makes it not Open Source,

Right, I'm not talking about the commit history, but rather that anyone (with means) should be able to produce the final artifact themselves, if they want. For weights like this, that requires at least the training script + the training data. Without that, it's very misleading to call the project Open Source, when only the result of the training is released.

> What's important is you can download it, run it, modify it, and re-release it

But I literally cannot download the project, build it and run it myself? I can only use the binaries (weights) provided by Meta. No one can modify how the artifact is produced, only modify the already produced artifact.

That's like saying that Slack is Open Source because if I want to, I could patch the binary with a hex editor and add/remove things as I see fit? No one believes Slack should be called Open Source for that.
Google's plan to drop third-party cookies in Chrome crumbles
+1 for trunk.
In comparison with Vite, webpack, etc it's not as mature. Fewer plugins and stuff, but for the use cases it supports it's great.
I use it to package a static Yew frontend and it works with minimal fuss and has hot-reload for dev too.
> Because whether they make 100x or 200x they make a shitload of money.

It's not a certainty that they 'make a shitload of money'. Reducing the right tail payoffs absolutely reduces the capital allocated to solve problems - many of which are risky bets.

Your solution absolutely decreases capital investment at the margin, this is indisputable and basic economics. Even worse when the taking is not due to some pre-existing law, so companies have to deal with the additional uncertainty of whether & when future people will decide in retrospect that they got too large a payoff and arbitrarily decide to take it from them.
Please start with the Windows Tax first for Linux users buying hardware...and the Apple Tax for Android users...
That's not exactly correct. The bürgergeld was planned to be a kind of basic income, but that part of it was axed. The conditions that apply move it to exactly the same social security money that existed before.

There is also statistically no existing move from work to existence supported by bürgergeld. It's just propaganda when that's claimed.
> Throw in unknown, and you've got a hat trick, a holy trinity of nothingness!

`unknown` is a top type, since we're on the topic of nothingness it'd be remiss to not mention its dual, `never`.

The pair is also called `Any` and `Nothing` in some other languages.
I hate to agree with the ridicule point, but honestly ridicule also deters other people from making a similar mistake.

I agree ridicule should be used cautiously, but in a case like this where someone speaks so confidently and boldly gives advice on a topic they clearly do not understand, I think ridicule is a good way not only to inform them, but also indicate to others that it's not okay to give people this kind of advice unless you have a basic understanding of the topic.
acme.sh has a list in their Wiki:
https://github.com/acmesh-official/acme.sh/wiki/CA
Now as many as 10k SAP jobs to be hit by restructure
This argument implies that cheap phones are bad since telemarketers can use them.
> For the CH Open, I'm not finding anything specific, even from Swiss websites, could you help me understand what you're referring to here

Was on the HN front page earlier [1][2]. The definition comes strikingly close to source on request with no use restrictions.

> all these definitions have at least some points in common

Agreed. But they're all different. There isn't an accepted defintiion of open source even when it comes to software; there is an accepted set of broad principles.

[1] https://news.ycombinator.com/item?id=41047172

[2] https://joinup.ec.europa.eu/collection/open-source-observato...
Counting from 0 up to a value is the standard for loop, or numbering things (possibly with using the value with an offset).

But like I said, I'm not so sure there is a right way to interpret it any more.
Agreed, but there are more major hotel chains than major airlines, for the purposes of providing a basic comparison. And this particular article was about them and Ryanair.
I mean the original comment that misunderstood marginal tax rates. That one looks very gray to me.

(And I think your comment is better without the ridicule! The sources you found for your follow-up comment are interesting and I learned from it.)
Time to bite the bullet and ditch the robbers
That analogy doesn't work. `train` is not a deterministic process. Meta has all of the training data and all of the supporting source code and they still won't get the same `weights` if they re-run the process.

The weights are the result of the development process, like the source code of a program is the result of a development process.
> It is free money for everyone. Everyone obviously excluding the people who work full-time and who are paying taxes so that "everyone" can live of Bürgergeld.

Oh wow, the exact thing people have been saying would happen has happened. Turn's out Quasi-UBI is a drain on tax paying citizens after all. Amazing.
Even though it's written in Rust, you can still use it in other languages like Python or Node.js. It compiles to a shared library file, which most SQLite clients support with `.loadExtension()` or another similarly named method.

This extension isn't the best example, since it's a thrown-together demo, but sqlite-ulid is a similar extension written in Rust that could be run anywhere, not just Rust

That being said, writing in Rust instead of C has many drawbacks (slightly slower, cross compiling, larger binary sizes, WASM is more difficult, statically compiling is complex, etc.). But for cases like this, many SQLite extensions I write in Rust are just light wrappers around extremely high quality Rust crates (like jiff), which makes my life easier and it "good enough"
> And the ceiling is limited as an employee, whereas it's virtually unlimited as a business owner.

It's also unlimited as a gambler. That doesn't mean everyone should start buying lotto tickets.
Show HN: Zerox – Document OCR with GPT-mini
This started out as a weekend hack with gpt-4-mini, using the very basic strategy of "just ask the ai to ocr the document".

But this turned out to be better performing than our current implementation of Unstructured/Textract. At pretty much the same cost.

I've tested almost every variant of document OCR over the past year, especially trying things like table / chart extraction. I've found the rules based extraction has always been lacking. Documents are meant to be a visual representation after all. With weird layouts, tables, charts, etc. Using a vision model just make sense!

In general, I'd categorize this solution as slow, expensive, and non deterministic. But 6 months ago it was impossible. And 6 months from now it'll be fast, cheap, and probably more reliable!
Show HN: I built a tool to expand your network (that introverts will love)
As someone who struggles with social anxiety, expanding my network through traditional means has always been challenging. I found existing networking apps either too spammy (LinkedIn) or too much like professional dating (Bumble Bizz), and they just didn’t work for me.

About a year ago, I developed a matching system for a local startup accelerator. This system connected founders, mentors, and investors based on industries, skills, and job functions, facilitating over 5,000 meetings that led to some amazing outcomes. Inspired by this success, I enhanced the system to focus on email introductions. Here’s how it works:
- It analyzes backgrounds and interests.
- It sends intro proposals to each person.
- If both respond, it makes the intro.

My goal is to help people meet interesting contacts without the stress, using email to keep the process simple and integrated into daily routines.
I’d love for you to try it out and share your feedback. Your thoughts and suggestions for improvement are greatly appreciated!
Hong Kong becomes major hub for shipping banned tech to Iran, Russia
We could definitely do a better job of learning from those who came before, it would save a lot of time and effort.

Evolution is messy, every combination has to be tried, every minor detail thoroughly investigated from all angles.
There are cases where if your salary goes up, your take-home goes down, especially for lower income levels. It’s just not on the basis of tax brackets. There are means-tested benefits that you can lose if you cross certain income levels where an increase in income of $5 can cost you thousands of dollars.
> If that is the case then the weights must inherit all these copyrights.

Not if it's a fair use (which is obviously the defence they're hoping for)
Small language models is the path forward
https://medium.com/thoughts-on-machine-learning/small-langua...
That's definitely possible and could be a reasonable tradeoff. I'd be slightly worried about the extent that it sacrifices write performance, but it might not be too bad if if the number of levels are kept small.
It's a common misconception because there are plenty of situations where making more money actually decreases your take-home pay. It's just not via the bracket system, it's via other incentives in the tax code (and welfare benefits in certain cases).

There are a lot of things (IETC for example, or benefits, or health insurance) which have $ cutoffs. Or tax breaks (i.e. electric vehicle credit) that only apply below a certain income. Exceeding those fixed points can certainly make you make less money.

One thing I ran into recently was fiscal incentives for homeownership (though not directly related to taxes) - there is a cutoff at a certain income level where if you stay below it you get a $10K credit towards closing costs. The tax code is full of things like that (or getting your student loans forgiven if you make less than $X for Y years).

If you want to see how bad the welfare cliffs are, there are cases where a single mother is better off making $28,000 per year (and receiving all federal benefits), than making ~$70,000 per year (and qualifying for none of them).

Image of the welfare cliff effect, example in Pennsylvania:

https://qph.cf2.quoracdn.net/main-qimg-7de186ce44f6a86805609...
This mostly only impacts verification of Lets Encrypt certificates. No changes for ACME users.
YouNeedABudget traditionally had good reviews for this sort of thing: https://www.ynab.com/

Unfortunately, they did move to a subscription model eventually :( I think V4 is the last one-time-purchase version. WayBackMachine has the downloads:

MacOS (x86 32-bit): https://web.archive.org/web/20190112221233/https://classic.y...

I think you'll need to convert it to 64-bit to run on Apple Silicon:
https://gitlab.com/bradleymiller/Y64 (didn't try it)

Windows: https://web.archive.org/web/20190112221246/https://classic.y...

---------

I don't use it anymore, so let me know if you want my old v4 license key.