skysight-inc/HackerNews huggingface dataset:
Not to be coy or disrespectful( and this is excellent work and a way to learn new things) but if one is generating a parser as a means to an end(the end being execution of the AST on the database), what are the learnings one gets from just the parser bit? Is it some kind of optimization you need to keep doing to the generated parser to make it more efficient?

Would a logical next step be Generate an optimal query plan from the AST(somehow..)?
Then shouldn't this be "I (a potential criminal) have nothing to hide from potential criminals working in the FBI”.
Rights be it positive or negative have to be weighed against each other. This is where societies tend to differ. Does your law side with the property owner or with the humanitarian rights of people who would need access to that property?

Typically, because those creating the laws are property owners themselves the law makers side with the property owners. Now if you are lucky you live in a society where the law makers recognized the crisis needs to be addressed and they usually find a way of throwing money at the problem (if you are less lucky, they do it corruptly by supporting their own property or that of their pals).

That means systemically we live in a society where those with power tend to accumulate more power, a phenomenom which leads to suffering and instability, which is why societies need certain guardrails against such accumulation of power (e.g. term limits, ethical frameworks, anti-corruption laws, taxation that doesn't tax poor people a bigger fraction of their money than rich people etc.)

But on the topic of the conversation: yes, you can claim a right that is not universally agreed uppon. That doesn't make it so, but throughout every progressive movement there ever was, this was a strategy. E.g. women claiming that voting is a universal right (in a context where they are barred from doing precisely that) is not stupid, it is clever. By appealing to the universality of a right you are also including those who already excercise that right on your side. In the example of women protesting for the right to vote framing it as an universal right includes men as well, this way a women issue becomes one of universal rights and will be discussed differently.
I think the post assumes some ML background (here OCaml). it is defining a type for the AST in a compiler.
I don't normally read articles here, but for some reason this time I did. I'm very disappointed that the fine article amounts to nothing more than a fatalistic tweet.

Edit: Fixed the typo in the word "normally".
You can't get .mp4 though. It's there somewhere inside YT app's persistent storage but there is no "share" button for it.
I wonder how far you could go with a combination of fine-tuning and a two-pass generate & audit process.

Step 1. Fine-tune a base LLM to the scenario. Feed it as much background material as possible. This would work best for a franchise with a huge extended universe or associated works: Dungeons & Dragons, Star Wars, Doctor Who, etc...

Step 2. Fine-tune / RLHF with negative weights against anything out-of-context. Basically, stop the AI ever referencing anything that can't exist in the fictional universe. Penalise references to real-world events, places, or people, modern technology, etc...

Step 3. Fork the AI model, once for each character. Fine-tune for conversations in that character's "tone" or mannerisms, backstory, etc... These can be via RLHF generated with a powerful model such as GPT 4. Again, reward/penalise the AI if it references anything it should or shouldn't know from that character's perspective.

When players play the game and converse with characters:

1. They'd always be talking to an LLM fine-tuned to death for that specific character in that fictional universe.

2. Then have both the input and output run past a general-purpose "nanny" AI that is prompted to look for exploits, out-of-context shenanigans, or unexpected output. Respond to the user with "I don't understand the strange things you're talking about" or some similar general push-back against jailbreaks.

Alternatively, have the generic security filter AI rewrite inappropriate terms in user inputs with unintelligible garbage. E.g.: if the user asks

"Are you a computer?"

Rewrite that to:

"Are you a gizwallop?"

Then the in-game character would rightly be confused by the nonsense term and answer something like:

"I have no idea what you mean, what is a gizwallop?"

Which could be translated back to:

"I have no idea what you mean, what is a computer?"

This would be absurdly expensive and slow right now, but in 5 years? 10?

I can imagine the cost of tuning the above for a GPT5-equivalent model dropping down to the budget of even a tiny indie game, let alone big-budget AAA game studios.
A good way to solve this is rationing.

It prevent over consumption, brings down prices and helps the poor.
Imagine if Windows would allow you to customize this at installation or at first login. Eg: Continue with default/recommended apps or customize bundled apps (where you can select none).
Where does have an unlimited right of free speech?

Because once you start threatening politicians in the US see how far it gets you. Post a picture of yourself with an AR15 and a comment of “looking for Biden” and see how well that first amendment works.
The people who created an entire video streaming platform with these blocks and rate limiting are more than capable of reading open source youtube-dl/yt-dlp and probably have been doing so for years.
> I can't remember the last time I watched any non-Netflix content on Netflix.

But that's exactly the point, isn't it? Netflix is popular today because it used to be the place where you could stream almost anything. Now you can only watch Netflix shows and movies, and some other low quality content or older shows and movies. Can Netflix keep up with more established media behemoths in producing enough content to keep its user base from flocking to Disney when they have all the most popular series and blockbusters?
Surprisingly, this display is miles better than the ones we keep seeing in new synths from some of the major manufacturers, like Roland and Korg.
Ask HN: What tech newsletters are you currently subscribing to? (August 2023)
I asked the same question back in July, and then I thought let's make it a monthly thing from now on.

Mine currently are:

https://www.pragmaticengineer.com/

https://bigtechdigest.substack.com/

https://leaddev.com/

https://www.ben-evans.com/ (thanks for recommendation tiffanyh)

https://hackernewsletter.com/
Could you add a phrase for beans in there?
You can use the make function in GO to create dynamically sized arrays. Awesome
No zero? Same mistake the Romans made!
Yes, only interested in the inference cost.
> but with Python you'll never even know what the real thing is like

What do you mean? Surely the concepts are similar regardless of using Python or C?
I'm not here to pick a side. I'm sure all of us can be more friendly to each other.

However, I'm a bit curious about when you say

> Suggesting that someone pours over documentation (and laughably source code) to explain patterns (or a lack thereof) in a highly abstracted language is counter-productive.

Isn't that what documentation is for? To learn about whatever's being documented. What would you suggest would be the better way to convey this information?

For source code, I can see your point. Although in my experience source code has the benefit that you can be certain that it doesn't lie. It does exactly what it says. Sometimes this can be a really nice benefit when trying to figure out what's going on. Regardless of the language or environment you are in.
What really sounds like something with the setup is not right to me is that Beached seems to say they have to cross their fingers every time they run just a plain update, not a release upgrade.

I remember often having to fix something when dist-upgrading Ubuntu when I used it on personal desktops between ~2005 and ~2014. I can't remember what kinds of issues there were, and apparently none of them entirely bricked the systems beyond repair since the same install survived throughout those years, but I remember it wasn't flawless.

But random breakage from standard updates within release is not something I remember happening on Debian, Ubuntu or modern Fedora with any frequency. (Except when I ran Debian unstable before Ubuntu, but that's a different story.) Double digit percentages, or even integer ones, do indeed sound like they are from a different planet.

I switched away from Ubuntu on the desktop over some dissatisfactions nearly a decade ago (and I never really ran Kubuntu) so I don't have much experience with that from recent years. But I've now had the same install of Fedora since 2014 that's gone through more release upgrades than I care to count, and while release upgrades still have a non-zero chance of breaking something, standard updates have been pretty much flawless.

I suspect there's something rather different about the setups of people who report no issues and that of someone who says standard updates frequently break in mainstream distros. Either there's a hardware difference or a difference in some kinds of 5% needs for the setup -- such as some specific software, specific peripherals, or specific needs. E.g. someone doing sound production might be much more likely to run into sound issues than someone whose sound needs are Netflix on USB headphones.

My last couple of personal devices have been ThinkPads that I picked in part specifically for the compatibility. The previous one with almost everything Intel worked pretty much 100% issue-free for years. I can imagine that if I instead had a random-brand consumer laptop or desktop, a wifi card with some kind of flaky half-support, proprietary NVidia drivers, some slightly niche peripherals, and the need to run some kind of a proprietary application dynamically linking with shared libraries from 2017, the story might be quite different.

Of course it might also be that some of us are just so used to dealing with fixing small issues or skirting around them that they just don't register for us any more. I think that's something that might also happen for some people -- tinkering is so natural that it doesn't feel like tinkering so tinkering doesn't exist -- and I wonder if that's part of the difference in the reported experiences.

But if someone reports a double-digit percentage of stuff breaking on a standard update, there's something else going on as well.
maybe helpful

https://en.wikipedia.org/wiki/CAP_theorem
> The UK has insane libel laws

It is somewhat strange since the tabloids are extremely toxic and spam gossip.
A Principled Approach to Transparency
It's like a communist party opens a dam or a factory earlier just because it's the party's anniversary.
Super cool breakdown, gg!
This article really needs an (2013), because of

> Both GHC’s core IR, Ur/Web's core and Coq are explicitly typed in this way.

This is how GHC used to do, but in 2018 GHC adapted the pattern "trees that grow"

The paper https://www.jucs.org/jucs_23_1/trees_that_grow/jucs_23_01_00... (the paper is actually from 2017)

Light GHC docs on it https://gitlab.haskell.org/ghc/ghc/-/wikis/implementing-tree... (I recall seeing more through docs somewhere). I will quote

> The new HsSyn AST supporting the TTG idiom (from now on referred to as TTG HsSyn) is designed to subsume five different representations of Haskell syntax:

> AST GhcPs: the AST used in GHC's parsing phase
> AST GhcRn: the AST used in GHC's renaming phase
> AST GhcTc: the AST used in GHC's typechecking phase
> AST TH: the AST used in Template Haskell
> AST HSE: the AST used in an external tool such as Haskell-Src-Exts

This means that you have a single generic tree for all of those passes, but each pass has a different instantiation with has custom data

Also, some discussion of applications https://www.reddit.com/r/haskell/comments/7zo9mb/any_applica... and slides here http://data.tmorris.net/talks/trees-that-grow/bc4ae902ca1d3b...

The thing about this is to observe that, in the blog post in the OP, when you added data to a given type, it was inserted as a concrete type (named Type here), that is, you went from

data Exp = Num Int
| Bool Bool
| Var Var
| If Exp Exp Exp
| Lambda Var Exp
| App Exp Exp

to

type TExp = (TExp', Type)
data TExp' = TNum Int
| TBool Bool
| TVar Var
| TIf TExp TExp TExp
| TLambda Var TExp
| TApp TExp TExp

But you could have kept it a generic type (here called a, rather than Type). This is a common pattern in both Haskell and Rust (and maybe other languages), and isn't the Trees That Grow pattern just yet, but it's like this:

type GenericTExp a = (GenericTExp' a, a)
data GenericTExp' a = TNum Int
| TBool Bool
| TVar Var
| TIf TExp (GenericTExp a) (GenericTExp a)
| TLambda Var (GenericTExp a)
| TApp TExp (GenericTExp a)

Now you can recover the original TExpr with

type TExpr = GenericTExpr Type

And you can recover the bare Expr with no added data type by putting () (called unit type) there

type Expr = GenericTExpr ()

Now, the paper also deals with the problem of, how to add new variants to a data type (it has a | Something that is open ended; this is called "extension constructor" in the ghc wiki, and denoted by XExpr), and how to add different data types to different nodes (you need to, instead of directly adding Type to the generic parameter, add a marker and use type-level functions - called type families in Haskell - to select the data type you're adding). When you figure out all those complexities, you end up with a type-level machinery that will inevitably be similar to the TTG idiom
I've seen several companies think this is a good idea but in practice it's a really bad idea to do this because you get captured by the customer and effectively become an arm of them without the benefits. And you end up dedicating so much time to them that other customers won't be happy and if that big customer ever cancels or leaves (which is often a board cost cutting decision rather than a user decision), then you end up absolutely screwed.
I don’t know if it applies to TEMU and AliExpress, but their originals (Pin Duo Duo and Taobao) cover different markets, with PDD being significantly lower in quality (and price). You can get sensors that work roughly fine on Taobao but with PDD you’d get one emitting seemingly random values priced at like $3.
You are right. I should add a warning. The "Web URL" regular expression has the advantage of catching "example.com/foo?q=bar#baz", not just "https://example.com/foo?q=bar#baz", but Gruber published it in 2014 (https://gist.github.com/gruber/8891611/revisions). I have not updated it.

I recommend normally using the script without -w and filtering the output for HTTP(S) URLs. The default regular expression (https://gist.github.com/gruber/249502) does not rely on a list of TLDs.

Edit: Added a warning to the original comment. Thanks for prompting me to.

Here is a version without the "Web URL" regex.

#! /bin/sh
# shellcheck disable=SC1112
set -eu

# The URL regular expression by John Gruber.
# https://gist.github.com/gruber/249502
re='(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'"'"'".,<>«»“”‘’]))'

grep -oP "$re" "$@"
solardev summarized my opinion of Musk pretty well.

I don't know enough about the space industry. SpaceX did introduce some pretty significant advances. But EVs: yeah they would have happened - eventually.

Big car makers sat on their asses (concerning EVs), and would have kept doing so for another 5..10y or longer.

Tesla took the lead, broke that market wide open, scaled up battery production enormously (which also served other applications like grid storage), and forced car makers to get in on the game or be left behind.

Those car makers would have produced EVs on their own. On their timeline.

But Musk kickstarted that market on his timeline. Years sooner than would have happened otherwise. Debate how many years all you want. But net effect is an enormous benefit to society.

Personally, I think it may come down to stress / pressure. Musk has worked hard, for a long time. Maybe he didn't get enough sleep. Or didn't get laid (often enough, anyway :-). NOT saying he did, but if it turns out he's been popping pills or snorting coke, I would be neither surprised nor hold it against him (or even care, tbh).

Regardless, such pressure tends to bring up the darker side in people. But who am I to tell Musk he needs a vacation?

Fun fact: bought a pack of 70 Li-ions recently (21700) for use on my boat. These were manufactured and/or designed by Samsung... for Tesla. I didn't buy them 'cause Tesla fanboy. They're not even the chemistry I preferred. But I got 'em because they worked out to the lowest price per Wh stored (in my case, ~800 Wh total for just over €100). Tesla-initiated economies of scale.

And in the meanwhile, there's now global internet access thx to StarLink.

Like him or not, feel free to think he's a lunatic or an asshole, but Elon Musk has pushed humanity forward.
data Exp = Num Int
| Bool Bool
| Var Var
| If Exp Exp Exp
| Lambda Var Exp
| App Exp Exp

An Expression is either:

- a Number literal, with an Integer value

- a Boolean literal, with a Boolean value

- a Variable declaration, with some identifier

- an If expression (probably), with a condition, taken, and not-taken Expressions

- a Lambda, which substitutes a Variable into an Expression

- an Apply, which is how we chain Expressions and apply the results of one expression onto the next

data Type = TyInt | TyBool | TyArrow Type Type

Our Types are TypeInt, TypeBool, or a Function (TyArrow) which goes from an input Type to an output Type
It wasn’t for emphasis. It was an effect. I was actually considering using the “code listing” form for it. I think I’ve done that, before.

Otherwise, I always use italics.

Feel free to go through my postings (there’s a fair number of them), and point out all the places I violate the Ts and Cs.
Nobody is against state.

But mutable state, that's another thing as it's harder to test, to reason about and leads to more bugs. It's not evil, it just has some drawbacks.

Code that you have to use a debugger to reason about just isn't as good as code you can reason about without one.
America has taxation.
For reference, Django has been downloaded roughly 2.8 million times in the past week while Phoenix has been downloaded 240k times. There's no doubt that the user base of Elixir is smaller, but it's not as tiny as you seem to think.
Made talk only four (cheated four is not actually in there)

http://move.rupy.se/file/talk.txt

Emoticon chat is the future.
Brooo look there is no state! Except that there is this massive state object being passed around!

I have experience from one Elm project at work and it is precisely like that, some massive state object that is passed around. No one wants to work with that project.
Lol such bs.

Go have a look on real estate sites and tell me you cant find 1/2 bedroom apartments for well under 1 million.

Op is single and clearly not telling the whole story about what he is willing to buy or where he is willing to live.

EDIT: Here did it for you: https://www.barfoot.co.nz/properties/residential/region=auck...

Plenty of places OP could look at if they were serious but they aren't. I'm not saying housing isn't in a bad spot as it definitely needs serious attention as a key (perhaps "THE") political issue. But hyperbole and lies doesn't help anyone or anything.
Ask HN: Website indexed, but not showing up in Google
The documentation website for our open source project Mapperly [1] is not showing up in Google, regardless of what we have tried to do. The site has been properly indexed, Google Search Console shows no (related) errors.

For example the search term "mapperly enum mappings" does not show results from the documentation. With Bing, this works fine. Strangely, results appear in Google when adding a "site:mapperly.riok.app" restriction.

Is this just another case of Google getting worse? We honestly don't know what we can try to make our website appear in the Google search results.

[1] https://mapperly.riok.app/
Yeah, but not guns. Check. Got it.
>Ethically, if you don't only think “fuck Google"

Companies do not have ethics, only interests. It's only natural I behave similarly.
Is there a reason this post keeps getting repreated?
Sorry, it said "Free Software: An Introduction" on the directory page[1], and also what I had in my notes.

[1]: https://stallman.org/Bob-Chassell/
“(…) probably try to ensure they are interesting and enjoyable, since you are more likely to stick at them.”

I agree. This comment reminded me of PG’s latest essay, where he writes about this. I can gladly recommend this text.

http://paulgraham.com/greatwork.html
College professors going back to paper exams and handwritten essays (ChatGPT)
Wondering what everyone else things. I teach English as a Foreign Language and am finding I need to make similar changes to my grading -- no more essay assignments or email homework. Thoughts? Suggestions? Ideas?
Does IA have some sort of legal fund one can donate to?

Edit: answered my own question: https://archive.org/donate
Conversely, since it's free do they not have a right to sell their app (even if selling it to someone evil is dickish) just as they have a right to decide to "update" it to remove well-liked functionality? Or just as they have the right to update it to add ads that support the dev of the app?

People/users will complain about all of these. I've especially seen people complain about ads; the only real issue I see is when there's no alternative to ads provided (ie subscription, pay a couple dollars to buy a copy of the app, etc). It's Google's mistake, tbh, as that's the common rhetoric with Youtube, people got it for free for too long to be happy with more ads. Blame the people who're uploading "120 hours of black screen" multiple times per day.
> But the temptation is always to just stick to the deadline and refuse to extend it, because once you extend it once then everyone knows it isn't actually a hard deadline and the deadline will get extended again and the thing will never get released.

Personally, I've seen so many "super duper important must-meet" deadlines which in the end turned out to be completely unimportant, that I've decided long ago that I'm not gonna do any more overtime to make any deadlines.

It's quite a sobering experience as a developer to stress over making a heroic effort to meet a deadline only to see after the deadline passed that actually it wasn't really so make or break after all, and that there was plenty of time to fix the issues afterwards. It's really not worth it to abuse your body and your mind by working overtime and spending too much time in a bad posture behind a computer just to make someone else happy.

Of course, I'll still do my best (I always do), and I might even agree to moderate amounts of overtime where it's warranted (as in: not because it is necessary because of shitty planning), but I'm not putting any emotional energy into deadlines, ever again.
The concepts and syntax are similar, but Python will always be "riding upon a horse", whereas C can be the horse.