skysight-inc/HackerNews huggingface dataset:
If longhand sums take years to learn we are doing it wrong and/or doing it at the wrong stage.

Laying foundations (counting, numerals) will take years sure, but they will be useful over various domains, but specific techniques shouldn’t be drilled. They are simple enough to pick up once matured a bit.

Like someone said, why calculate sin(x) when you can use a lookup table. I mean, sure, do it a few times when you are ready to appreciate it but forcing it down young kids’s their throats for years on end is detrimental.
I wouldn't charge less because you did it quicker, when on the other hand you would probably not charge more if something took you longer because you had to fix a bug or something with a library you are using. I think if they get what they need all is good.

If a client saves 4 times what you charged, then that isn't too crazy. You should capture ALL of the value right?

And some companies like Google capture that kind of ratio from all of their employees!
The second video is from Usagi Electric. He did a recent colab with Veritasium on lightbulbs (vacuum tubes). His videos are awesome and he has several different cool projects running.

1. 1-bit Vacuum tube computer

2. Centurion Mini computer (whole series, amazing)

3. Wang Writer

4. PDP-11 (just started out)

5. Liton mini computer with drum memory

6. TI-99 computer
> Why would you ever need a different KV store when you have Redis!

If you want to have tier based storage, where you trade off latency for increased data size, meaning disk space is your limit and not your RAM.
The fact that two major attempts to do split/segmented stacks, Go and Rust, both ended up abandoning that approach to me indicates that there are fairly big problems trying to go beyond traditional stack model. Without even acknowledging the difficulty, nevermind proposing solutions, the blog post reads very much like "I want a pony"
> The Billion Dollar Mistake lives on.

I disagree. There is a big difference between configuration language formats and programming languages.

> To my mind, a configuration file using "this key doesn't exist" as one of several valid options seems deeply unsound.

I would agree, but in that case you now often need a secondary key to "turn something off" which is often not done.
apropos the roomba founder, a nontechnical argument for necessity of embodied AI circa 1980 (5 min video)
https://youtu.be/QMMw9fQ452c?t=49

That LLMs learn a world model is very convincing now, but as LeCun has said it's just one piece of the intelligence puzzle, incl. perceiving, actuating shenmede
Sad. For the most part transhumanists are simply hopeful for the future and what technology can do to elevate us — as it already has in many ways.

This article is just malignance from a Luddite worldview. It gives us no place to go — you should be happy with things as they are.

It feels like a visit to an old folks home.
> Not to mention all the taxes paid for the road, interstates, etc.

Though it should be noted that roads had existed before cars (and were paved with the help of cycling advocates), and interstates/highways between cities are useful for commerce.

It is the extreme focus on making everything car-centric for personal transportation that is the problem. Having cars as an option isn't a bad thing; having them as a necessity is where most of the issues come from.
I can see the argument for using it with frameworks and libraries as it can discover the library functions that do what your prompt describes for you.

It seems to have a lot of trouble with building code that works in a certain way. For example if you ask it to build a simple graph container with access functions that give you iterators over neighbourhoods of nodes or whatever it makes a mess. Sometimes it technically works, but the underlying graph datastructure is just ripped out of randomseocodingsite.com using nodes owning pointers to their connected nodes.

If you ask it to use a specific underlying structure like a vector of nodes and indexes to represent edges it doesn't quite know what to do.

So yes, I guess the initial implementation "works", but not well.
People are quick to forget, but the internet is not.

Even if he stops posting today, and deletes everything he has control over, he'd still be all over the net. Easy target for truly malicious people.
Well for me personally, the proof is in giving it a few sentences on how it should write fairly complicated pieces of unique code I need on a daily basis and seeing it correctly infer things I forgot to specify in ways that are typically borderline impossible for anything but another human. If that's not reasoning I don't know what is.

The other one that convinced me was this list: https://i.imgur.com/CQlbaDN.png
I think the leetcode tests are quite indicative, going as far as saying that GPT-4 scores 77% on basic reasoning, 26% on complex reasoning and 6% on extremely complex reasoning.

Maybe the reasoning is all "baked in" as it were, like in a hypothetical machine doing string matching of questions and answers with a database containing an answer to every possible question. But in the end, correctly using those baked in thought processes may be good enough for it to be completely indistinguishable from the real thing, if the real thing even exists and we aren't stochastic resamplers ourselves.

> aided by human interpretation on top of the text output

That's an interesting point actually, I've been trying to do something in that regard recently, by having it use an API to do actual things (in a simulated environment) and it seems very promising despite the model not being tuned for it, but given that AutoGPT and plugin usage are a thing, that should be all the evidence you need on that front.

Google also did this with their old Palm model which is vastly inferior to even GPT 3.5: https://www.youtube.com/watch?v=j6O_uePUKKI
It also reminds me the syntax of INI files.
> Going on vacation to Europe is a totally reasonable thing to do. Don’t let people guilt you into believing it’s an outrageously selfish act that contributes to the destruction of our planet.

Reasonable by what standard? How is it not outrageously selfish to add extra carbon to the atmosphere which absolutely does “contribute to the destruction of the planet”.

Do you honestly think there are zero consequences to burning further fossil fuels?
good thing is, you can program the layout yourself. you can even put the parentheses in homerow and access it by holding one of the thumb keys and tap a key in homerow.
Curious at to what technologies you work with? The work that I do and tools that I use have all manner of configuration file syntaxes and languages and a big headache for doing sysadmin work is trying to remember if a particular .rc file uses INI, YAML, JSON, TOML or some home rolled nonsense.
In PDFs you can even include that invisibly.
The author should really look at Nim.
Lmao imagine looking at a number and making a judgement based purely on it. People here are pretty shallow on issues like these.
Yeah frankly it’s hard to understand how you can’t get value from ChatGPT as a programming companion.

Either you already know how to do everything or you’re not asking it a wide range of questions about the work you’re doing.

It’s not there to write your code for you, although it can write snippets and short functions. It’s thereto answer questions like “how do I….”, “how does this work”, “explain this code”, “what’s the correct typescript type for….”, “what’s the maximum decimal of uint16”, “difference between and y”, “give me an example of”, “what are the arguments to”, “what causes this error”, “explain this code”, “given this data structure, how do I get the third row, first item”, “how do I Centre a div”, “create a header file for these functions”, “what’s the command to compile this code”, “what’s the regex to get lines containing foo”, “ffmpeg command to convert X to y”, “given this sql table, write a query to …”, “make 1000 rows of sample json data with fields name address phone”, “write a sed command to search and replace X with y”, “create a cmakelists to compile this”, etc etc and critically important “that didn’t work”, “another approach”, “any other ideas?”.

Then you debug the code it gives you.
JSON is basically perfect if it allowed trailing commas and comments. TOML is not a replacement for JSON because of how badly it chokes on nested lists of objects (being both hard to read and hard to write), due to a misguided attempt to avoid becoming JSON-like[1].

[1] https://github.com/toml-lang/toml/issues/516
The U.S. Left Them Behind. They Crossed a Jungle to Get Here Anyway
It's not improper it's just non-optimal.

And we have had non-blocking I/O for quite some time now.
> What happens with most of these, is light rail goes to the city for a few surrounding suburbs with 50-100k people per town. To get to that train station every morning, you need a car. No, you cannot have a bus circle the suburb for an hour to pick everyone up.

If the suburb is designed to be walkable then the bus is not needed in the first place:

* https://en.wikipedia.org/wiki/Streetcar_suburb

* https://www.youtube.com/watch?v=MWsGBRdK2N0

Each individual community or neighbourhood can be fairly self-contained with regards to daily needs, and travel between them is done on rail or whatever. One could have all-day, frequent (e.g., every 5 minutes) service with trams (or buses) with-in an area, where you can travel with-in it, but also have connections to commuter rail to go to the Big City if the need arises:

* https://en.wikipedia.org/wiki/Commuter_rail

This is how things were generally built post-railway, pre-WW2. (Pre-railroad things were generally all walkable, but long distances being done on horses or boats.)
It's been discussed a few times over the years:

https://github.com/toml-lang/toml/issues/921

https://github.com/toml-lang/toml/issues/803

https://github.com/toml-lang/toml/issues/802

https://github.com/toml-lang/toml/issues/146

https://github.com/toml-lang/toml/issues/30

Obviously there is a bit of a demand, and it certainly has valid use cases, but also has downsides.
> This is misreading my comment, at best.

If you don't like the characterization as a panacea, what would you prefer - jack of all trades maybe? All-purpose language ?

> This has been discussed again and again on HN, and the answer to it still stands to this day. So now I'm not giving you the benefit of the doubt.

I'd guess you're thinking you'll measure and just rewrite the hot code paths. The problem is in too many cases when industrialising software it's basically all hot, the heatmap just all glows red. Google people did talks about this maybe a decade ago, it's why Go ended up getting internal support, because if you write software the first time in a language with better performance you don't need to do the rewrite.

I think Python's actual strength is as a language for people whose job isn't primarily to write software. Let me give an example of a choice Python made (admittedly not for years) that is exactly what you should do for that audience, and then the opposite:

Ordered Dictionaries make dict have reasonable performance and yet also behave how naive users who have only a limited understanding of how the machine works would expect, which means they produce less buggy software in practice

Multiple Inheritance is too complicated to teach to a class of say, Geographers, and yet it's not really crucial for the underpinnings of the language, so why go to such lengths to support this feature ?
The abstract claims, "whereas native writing samples are accurately identified", which is very different from claims I've seen elsewhere about how well these detectors work. The test they're reporting is running the detectors on "88 US 8-th grade essays sourced from the Hewlett Foundation’s Automated Student
Assessment Prize (ASAP) dataset", and they got a false positive rate of ~10%.
As the West surges toward electric cars, the unwanted gas guzzlers go [to Benin]
A SOL-20 computer from 1976 – Museum restoration
This engineer has a series where he carefully restores a Processor Technology SOL-20 Terminal Computer, the world's first true home computer (1976). The computer will go to the Dutch Home Computer Museum once restored.
LambdaLabs is offering free compute to train open LLMs
Because MAME is effectively an emulator for arcade games and dolphin is a state-of-the-art console emulator? It is generally not be possible to get the level of fidelity and performance of a custom emulator out of a general-purpose framework like MAME.
I think this indicates a bigger problem, we still of math as arithmetic, especially in education. Arithmetic should be viewed as a specialised branch of math, something only learned in depth if you have skills, interest and aptitude. We should focus more on introducing kids to the full breadth of mathematics superficially and then letting them explore and expand their understanding and skills from there.
That's what Rust does, you can only register with crates.io with a GitHub account.
It would probably just have a bunch of anxiety about a better version of itself causing it's extinction and spend all it's time researching alignment.
CSS has two magic values that would be useful in many configuration scenarios:

- unset: ignore values of this property

- initial: use the default value

These would be useful e.g. with overrides.

I agree that nulls in a config files are often not a good idea because it is not clear how they are going to be interpreted.

PS: Css also has inherit that could mean "use the local default" while initial could mean use system default.
Why do you think giving people more choices would lead to people being less mathematically inclined? I think the opposite might happen.
What you guys seem to be describing is "Freenet", but that project has been around forever and relatively obscure. These days, unfortunately, I wouldn't touch it with a 10ft pole due to safety concerns.

https://en.wikipedia.org/wiki/Freenet

"Freenet is a peer-to-peer platform for censorship-resistant, anonymous communication. It uses a decentralized distributed data store to keep and deliver information"

From what I remember, it basically takes content and distributes "anonymous" and encrypted chunks of it across various members on the network. Content stays active by being replicated, and replication happens proportionally based on popularity. So content that never gets used basically disappears.
If a GPT detector has any false positives at all it will disadvantage people who are already disadvantaged. They are the least likely to be capable of defending themselves and the least likely to be heard if they do try to defend themselves.

Not to mention the fact that being called non-human is most definitely going to offend some people.

What exactly makes anyone think that they can detect an LLM that is outputting text? The notion seems absurd yet it keeps coming up.
The default stack size in most OSes is tiny, and when programming in a low-level language (including Rust) it's important to keep large allocations off of the stack. That's why Rust has Box/Vec and the various APIs in `alloc`, and why the cross-thread primitives take ownership of their values.

You can "transfer" a 1 GiB `Vec` between threads without having to actually copy it, which is not true of stack-allocated values.

The relative scarcity/cost of the stack vs heap only gets more extreme as the machines get bigger. My desktop has 128 GiB of RAM, and `ulimit -s` reports a default thread size of 8 MiB. A typical rack-mounted server is going to have 1 TiB or more of RAM, and almost certainly the same stack size.

Could I make the stack size bigger on my machine? Sure, yes, but what would that get me when the entire world writes software with the assumption that any allocation over a few dozen MiB needs to be on the heap?
Arch Linux: Git migration completed
Well I am at least glad that someone name drops someone other then TBL.
Why not compile curl with c-ares?
I know `pip search` has been disabled with PyPI for a while now due to a constant deluge of requests overwhelming the backend. Knowing that, and seeing this update, makes me think that PyPI is subject to an exceptional volume of malicious activity.

Does anyone know if it's true that PyPI receives more abuse than similar projects and, if so, why?
I don't know about mess. Is it an emulator collection? Dolphin is a Gamecube emulator. Would that be a good addition to mess?

Maybe one good reason is to constrain project goals in scope.
journalists have been replaced by GPT a long time ago. You've been reading GPT2 generated articles for longer than you probably realise.
> There is a big difference between configuration language formats and programming languages.

You're right! But in my opinion the difference is that a configuration file should have a default state that could be written to disk and loaded with no change in behaviour.

eg you can set `feature = "on"` or `feature = "off"` and if you don't set either it's the same as writing `feature = "off"`.

Having a secret third thing of `feature = null` should be outlawed and I'm glad TOML doesn't encourage it
Dolphin is amazing. I remember its progress performance-wise. It used to use multiple cores at high load, which to me was understandable, because it emulated a gamecube after all. But at some point they found some intermediate language optimization and performance became superb. I was then able to run it on a nowadays rather weak laptop at low cpu load to play Metroid Prime flawlessly.
You can think of key / value as a subset of document namely one with a single index
> There is a big difference between configuration language formats and programming languages.

In general: I agree. But configuration formats (including TOML) also need to map well to programming languages, so you can't seem them as entirely separate. One argument against Null is that it doesn't elegantly map to a data structure in all programming languages.
https://github.com/xldenis/besm

Last commit:

first complete version of PP-2
Rust stacks are only 2MB by default. That is some 4-5 orders of magnitude less than typically available heap.
I finally decided to install Copilot recently now that they have the business subscription with a more sensible privacy policy, and it's so much better than expected. Even on internal code it hasn't been trained against it often just works anyway based on the context and other nearby code.

If something requires even a slight bit of boilerplate that has a pattern to it, it writes it much faster than I could. I find it almost uncanny sometimes how well it knows what I wanted to do next even without writing any comment telling it what to do. Not to mention the hundreds of random small suggestions like writing similar method definitions, completing all of the parameters I was going to pass to something, writing out the rest of some math formula after I typed the name of the variable for the result I want to compute, etc.

People weren't kidding about the productivity boost. On the other hand, I found trying to get ChatGPT to write large chunks of code almost completely useless - it would always be incorrect in some subtle way or failing to use the style I gave it as an example, unless the task is to write some simple python scripts.
https://archive.ph/Hq7cQ
Cultured meat is all bullshit marketing until supermarkets at least sell simple tofu for less than chicken. It's just mashed-up beans, loads of water and a teaspoon of rock powder!

The Chinese supermarkets can do it, but in normal supermarkets, everything meat-free is positioned as a luxury rich-people thing. Organic this, handmade that, marinated the other. Hovering at £6 or £8 a kilo. Meanwhile the shelves next to it are groaning under endless kilos of chicken from £2.50 (1kg of legs at Tesco, was £2.15 until recently).

My tin-foil hat theory here is that they don't want to knock the bottom out of the meat-free market because they're hoping to replace cheap meat with expensive synthetic meat and not let on that it's a false dichotomy.
I have no doubt that it will be supported on systems other than Linux soon enough. There's nothing really special about Linux other than it's my daily driver, and testing elsewhere is not the fun part of hacking.
Air travel is 2% of global emissions. It's a drop in the bucket.
Unfortunately that's not what `unset` does and I feel like the confusion it causes and the complication it adds to any CSS parser suggests it's a bad idea!
People think Redis is just a cache because the use the puggified version sold by AWS (elasticache). Enable persistence + AOF (the write ahead log) and you got yourself a database.

You can also add your own data structures to Redis, not as a form of syntax sugar over KV pairs, but as a dynamic library that you can write in C/C++/Zig/Rust, where you have full control over the in-memory representation.

But that's also another feature AWS takes away from you if you buy elasticache :^)
Speculation on my part, but I believe us non-native English speakers write more formally and with less natural flow.

I also wonder which proportion of English writing (in general) is written by non-native speakers, and whether we might be disproportionately represented in training data.
GPT-4 has a bit of a bias towards overly formal, "textbook" English, which could be similar to what many non-native speakers learned.
So something like https://httpbin.org (which BTW recently has some capacity issues)
That's already fixed; in the upcoming TOML 1.1 you can write:

tbl = {
hello = "world",
}

All the examples in the issue you linked should work.

https://github.com/toml-lang/toml/pull/904
Whilst I agree, you're reading too much into the article. The article says more about the standard of journalism in FT than anything based in reality.

Look at who wrote it:

https://www.ft.com/madhumita-murgia

https://www.ft.com/bethan-staton

Do you think either of these people have an innate understanding of the education system and its syllabus? They're journos. One of which is their dedicated AI hot take specialist.

It's a throwaway piece that's a vehicle for ads.
Stack limits exist because of the halting problem. If we knew in advance which thread would need extra contiguous memory for deep recursion using variables of automatic storage duration we could allocates its stack at an address with enough space left.

We should just solve the halting problem. The we'd no longer need to implement automatic storage duration and call frames by using stacks. It's just that easy.
There is a secret third thing called "feature not in file" and most TOML implementation encourage it as "key not in file" is typically returned as `null` or `None`. That's how so many TOML files in practice end up with all these secret values.

It's also particularly odd in lists where I have seen `["foo", "bar", {}]` show up in the real world with `{}` being used as a replacement value for null.
Looking at investment levels in content versus technology in the kids space
It seems quite natural that it’s easier to interpret correctly written English than language that contains mistakes. Does anyone find this controversial?
Check out the writeup: https://github.com/tpai/gandalf-prompt-injection-writeup
> The detectors demonstrated near-perfect accuracy for US 8-th grade essays

I am genuinely confused.

It seems that all the test data provided were real human essays. The ones provided to GPT as native English speaker ones are from a prominent machine-learning data set of common essays, that seem likely to have been included in any training data, where the non-English ones were taken from a random forum.

Can someone help me understand if I’ve understood the flaws correctly here? If so, does this paper add anything beyond just confirming that there’s at this point of time absolutely no value in GPT detectors?