skysight-inc/HackerNews huggingface dataset:
N.B. that the ordering matters here — Generalized Artificial Intelligence is not the same thing as Artificial General Intelligence
Ok so as I understand it the flow was something like:

1. Individuals deposited to Yotta
2. Yotta sent deposited funds to Evolve Bank via Synapse
3. Evolve Bank received "lump" deposits with no record of whose money was whose

So somewhere between Yotta and Evolve Bank the money was pooled and records of whose money was whose was not forwarded. (Note that the FDIC now requires that the receiving back keep a record of whose money they're receiving because of this case.)

Synapse went bankrupt. Supposedly Synapse's estate can figure out where everyone's money went, but they have no money to hire an auditor. Meanwhile Evolve Bank says they didn't receive all of the funds so there's something like 90 million that is "lost".

Finally, the FDIC ruled that individuals had business relationships with Yotta, and those business relationships are not insured by FDIC, so any recovery of funds from Yotta would need to be pursued in Civil Court.
So when will prey evolve to always face southwest?
if they have almost the same motherboard, they should sell upgrade kits like framework
I’ve definitely seen an undercurrent of “I don’t need the crutch of a debugger” sort of attitudes online over the years, never really made sense to me. It can be painful pairing with someone who keeps adding print statements one at a time and repeating the 15 step process to get to them when they could have put in a breakpoint right out of the gate.

I still print stuff plenty, but when the source of an issue is not immediately obvious I’m reaching for the debugger asap.
> Building out data centers feels like a far more difficult problem.

Is it really? I'm thinking it might be more time-and-money-involved than building a "LLM product" (guess you really meant models?), but in terms of experience, we (humanity) have decades of experience building data centers, while a few years (at most) experience regarding anything LLM.
> So please refrain from calling people with different preferences uneducated.

OP said:

> … people who lean on print debugging often have incomplete knowledge of the immense power of modern debugging tools.

I am educated. I have a metric fuckton of incomplete knowledge in all areas of life.

You’re poking at something that wasn’t said.
There's always someone who doesn't get it. It's free to the user, that's always implicit when you read "free".

We all know that money doesn't grow on trees, no need to treat us like children.

> so that users can decide how much trust to place on its survival, and how risky it is to build a dependence on it

Dependence? This is for people who have no other access to phone calls. I find it funny to complain about such a service when there is no alternative for the target users.
I mostly use print debugging and not because i don't know how "real" debugging works. It's just that most of the code i deal with, deals with data that's flowing real time. So you stopped on a breakpoint, and the app broke already because incoming data and/or what consumes output, didn't stop.

The data streams of course can be simulated, then "true" debugging with breakpoints and watches becomes practical, but the simulation is never 100% and getting it close to 100% is sometimes harder than debugging the app out using print debugging. So with most of the code, i only use debugger to analyse crash dumps.
Esoteric: I use print debugging on a Lisp Machine using a presentation based Read Eval Print Loop (REPL), similar things would work in some other Common Lisp environments. Presentation based means that the REPL remembers all output and the objects associated with that output.

(defmethod move ((a-ship object) (a-place port))
; do something
)

(defmethod move :around (what where)
(print `(start moving object ,what to ,where))
(call-next-method))

Above prints the list to the REPL. The REPL prints the list as data, with the objects WHAT and WHERE included. It remembers that a specific printed output is caused by some object. Later these objects can be inspected or one can call functions on them...

This combines print debug statements with introspection in a read-eval-print-loop (REPL).

Writing the output as :before/:around/:after methods or as advise statements, makes it later easier to remove all print output code, without changing the rest of the code. -> methods and advises can be removed from the code at runtime.
Dick Hurtz was disappointed he didn't make the list.
I like debuggers and use them when I can, but folks who say you should only use debuggers tend to not realize:

* Not all languages have good debuggers.

* It's not always possible to connect a debugger in the environment where the code runs.

* Builds don't always include debug symbols, and this can be very high-friction to change.

* Compilers sometimes optimize out the variable I'm interested in, making it impossible to see in a debugger. (Haskell is particularly bad about this)

* As another commenter mentioned, the delay introduced by a debugger can change the behavior in a way that prevents the bug. (E.g. a connection times out)

* In interpreted languages, debuggers can make the code painfully slow to run (think multiple minutes before the first breakpoint is hit).

One technique that is easier to do in printf debugging is comparing two implementations. If you have (or create) one known-good implementation and have a buggy implementation, you can change the code to run both implementations and print when there's a difference in the result (possibly with some logic to determine if results are equivalent, e.g. if the resulting lists are the same up to ordering).
I find the people quick at fixing bugs are even quicker at introducing new bugs.
But they can stop most, just like laws can stop most. I don't think it's logical to imply that if something isn't 100% effective then it's worthless.
The Fight to Free JavaScript from Oracle's Control
How is side-eye different from dtrace?
Ancient forest world discovered 630ft down sinkhole in China
4.45B-year-old crystal from Mars reveals the planet had water
The good, the bad, and the ugly behind the push for more smart displays
You can make your breakpoint conditional on the conditons you're looking for, then it'll run full speed until you hit the timing edge case.

Best of both worlds.
Hey, poster here.

This is a blog post about a project by a good friend of mine who isn’t active on HN, so I’m sharing it here to help bring awareness (similar to what I did for another friend’s project previously). I genuinely think his tool, Angus TV+, is amazing. It's simple, clever, and thoughtfully designed. Plus, he writes really well!

It’s still in a loose public beta, but it has real potential to bring value to people who love TV and movies or want a more social, organized way to manage their media habits. I’d love to hear what the HN community thinks. Feedback, feature ideas, or just general impressions would mean a lot to him!
I used OpenMPTCPRouter to aggregate 3 LTE connections (via routers connected to directional antenna, with SIM cards from different operators) when I was living in a house in the woods before the war has started I had to leave Russia.
Worked like a charm, giving me up to 180 Mbps or so. May not be that good for aggregating different types of links together, but for using multiple cellular connections it's nearly a perfect solution.
BTW 5G 3GPP specs include MPTCP support, IIRC for aggregating connections going via different gNodeBs (base stations)
> It can be painful pairing with someone who keeps adding print statements one at a time and repeating the 15 step process to get to them when they could have put in a breakpoint right out of the gate.

This does sound painful, but this is not what most people who advocate for print debugging are advocating for.

If I'm only going to add one print statement, that's obviously a place where a breakpoint would serve. When I do print debugging, it's precisely because I haven't narrowed down the problem that far yet—I may have ten theories, not one, so I need ten log statements to test all ten theories at the same time.

Print debugging is most useful when the incorrect behavior could be in one of many pieces of a complex system, and you can use it to rapidly narrow down which of those pieces is actually the culprit.
And who gets, uh, takes the credit when one of the PhD students "breaks through"?
"Yes, we charge exactly what Amazon charges. We don't add any markups or fees for the price of the product"

How do you make money / not lose money then? Coinbase is charging you 1%
>Because if you allow it, you'll have hundreds of these everyday. The law is there to "scare" others from doing it not punish the perpetrator. On the other hand, you don't have hundreds of fintech startups raising millions >every day.

Surely the scale of harm caused is the metric here, and not the frequency of potential crimes individually committed
I’ve also done Wednesday to Wednesday, though Tuesday seems better mentally if only because there is one less day after the new week starts.

What is much better, though, is splitting the week into a 4/3 or 5/2 split, with a primary and backup on-call. Primary takes the weekdays, then switches with Backup for the weekend. You’re still sharp and aware of any current issues should the need arise, but the odds of a weekend page are (hopefully) lower, so you can relax a bit.

This of course requires enough people to have a reasonable rotation; 6 at a minimum, but 8 is better.
Well, no, clearly :)

It’s being different that gives the edge. Of course edges and precipices can have their own dangers too…
I think in this case, because everyone brings up multithreaded examples when saying a debugger isn’t useful, maybe print debugging can lead you towards the path of where to use a debugger efficiently.

I personally think if you can’t use a debugger in a multithreaded codebase, the architecture is bad or one doesn’t understand the code. So yeah, full circle, if print debugging helps one learn the code better, that is only a positive.

I’m so amused about how debuggers have become a debate around here. “Printf vs debugger” is like “emacs vs vi” right now, and it really shouldn’t be. Sometimes I put a breakpoint AT my printf statement.
Totally Gridbag (2005)
There are varying extents for ulysses pacts that can be taken as a project owner, though.

Tuxedo screwed themselves silly by taking too strong of a pact with their drivers, for example. Instead of going all the way with a CLA that effectively transfers copyrights to the project owner, you could go for a DCO under a less-restrictive, but still copyleft, license. For example, on an AGPLv3-only project, the DCO would require contributors to state their contributions are under GPLv2+ or maybe LGPLv2.1+.
Displaying this would be a fun use of the Las Vegas Sphere.
I've heard that too - I've never had the good fortune to with on a codebase where the was practical though.

I've never satisfied myself that you can't just make a legacy codebase work that way, given enough effort, but I am not fully convinced it's always a good idea.
Would be great to see an earth or moon or country map outline for scale.
Comparatively modern. Printf debugging is clearly a less modern tool than a fully integrated debugger, even though as you say those are decades old.
I'd love for someone to explain to be how you can use a debugger cross half a dozen languages. Print works on everything from forth to python. In my experience you need to learn at least one debugger per language with a whole bunch of corner cases where they are outright misleading. Has the situation magically changed in the last 10 years?
Musk will eventually understand that part of the goal of government outlays is not getting the job done, but simply to spend money to keep the wheels of economy moving.
The static nature of LLMs is a compelling argument against the reasoning ability.

But, it can learn, albeit in a limited way, using the context. Though to my knowledge that doesn't scale well.
You defined "m" as the measuring function which is not the pseudo-random number generator itself. I guess I don't understand your definitions.

In any case it's pretty obvious you have have deterministic chaotic output from which you cannot practically (or even in theory) recover the internal workings of the system that generated them. Take just a regular pseudorandom number generator or a cellular automata.
Yes, I see that it’s been years. That’s why all your examples are ancient news. Consider other people might be active, and that you never actually refuted my point.
Yes, but then imagine saying on the next stand-up that you took a couple hours or a whole day on adding new NATVIS visualizers or GDB pretty-printers, and think of the reaction you'd get. Approval and interest, or eyerolls and comments on work prioritization? That is the difference between the two cultures. It matters at least because use of debuggers gets more effective with investment into support scripts and configs, in ways print-debugging doesn't.
> And if you step past something but then later realize it was important, time to start over.

How can you do this using print debugging? For every print statement I add, I can add a breakpoint. Even more importantly, I can see the stack frame and know which functions led to the current one. I can inspect any and all variables in scope, and even change their values if I want to pretend that the code before was fine and proceed further.
From a practical standpoint, for anyone who needs to parse SQL today, I can recommend datafusion's sqlparser-rs. This is what we use in http://sql-page.com , and I regularly contribute to it. I don't know anything else that matches its level of support for all the crazy little-known syntax particularities of the various SQL dialects.

In particular, Microsoft SQL Server seems to do everything just a little bit differently, and sqlparser-rs does support its idiosyncrasies most of the time.
It should work to profile neovim, does it use the luajit shared library or is it statically linked? You could run parca-agent and set up a filter to discard all non-neovim samples and leave a parca instance running locally and just restart it periodically.
Awesome work. Thank you for sharing. Yes, web technologies coming with web browsers, HTML, CSS, DOM, JAVASCRIPT, PHP, .., can be used directly inside web browsers. This is how I use them to build a tiny web text editor coming with a programming language : http://lambdaway.fr . Your opinion would be appreciated.
Sorry I hadn’t heard of this. It’s just my ignorance. I’ll take a look and consider editing it in.
It is free. Can you share what you were searching for? Maybe i can check for any errors.
The thing is, in interpreted languages land print debugging has a power no debugger gives you: live debugging on your production instance.

Something is broken in prod, you cannot reproduce it in your test environment because you think it may be due to a config (some signing keys maybe) you can't check. And it looks like someone forgot to put logs around whatever is the problem.

You can either: spend multiple hours trying to reproduce and maybe find the cause. Or take 5mn, bash into one of your nodes, add some logging live and have a result right now: either you have your culprit or your hunch is false.
I have the complete opposite experience. I learned how to use a debugger from the only 10x programmer I’ve ever had the pleasure of working with.

Person was a wizard at finding bugs. And they didn’t write many. My goal in code reviews was to find them from this person. I found 2 in 5 years.
Looking Back at the Future of Humanity Institute
Exactly this. Nobody is looking down on print debugging. Everybody uses it. People are looking down on those that stop at print debugging and never reach for a full debugger.

It's particularly annoying on projects that are set up without considering proper debuggers, because often it's impossible or difficult to use them, e.g. if your program is started via a complicated bash script or makefile rather than directly.
Cool!
But then there's the 'lamp' part. The idiom is a little more indirect - doesn't 'smell of' high technology. Just smells of it's lamp.
That's a hell of an assumption to make and I don't quite understand your reasoning. Debuggers are complex, true, and often people don't understand their potential. People, however, approach learning code and associated tools from many different directions, backgrounds, assumptions, and biases. If I were to read beyond your words and guess why you're so emphatic, I sense that you're coming from a distinct background (I won't bother guessing) where this is either obscured from you or where you've been allowed to forget.
I developed it so i know it is not a scam and it is open source btw. https://github.com/zaidmukaddam/miniperplx
https://www.youtube.com/watch?v=HJEmE7IYoLk

Summary: colleges are way too selective today at the high end.

Boomers got into elite schools far more easily, although there were less schools.

It's a bit of a disingenuous argument however, because the huge increase of schools down the long long LONG pecking order of school "eliteness".

But the boomer thing is spot on.
Funny, I'm 33 and DSA "inspired" me not to go to FAANG+. Of course, not the DSA themselves, but rather, leetcoding. Good luck on your journey!
Sometimes it's easier to add 3 printf() than to run your project under a debugger.
I said such users often have incomplete knowledge. Are there exceptions? Sure. Of course there are.

"Those are all things we had many decades ago"

I didn't claim this is some new invention, though. Though as someone who has been a heavy user of debuggers for DECADES, debuggers have dramatically improved in usability and scenarios where they are useful.

"So please refrain from calling people with different preferences uneducated."

But...I didn't. In fact I specifically noted that graduates of excellent CS programs often haven't experienced how great the debuggers in the platforms they target are.

We all have incomplete knowledge about a lot of things.
This actually doesn’t work with modern expectations.

Modern games are expected to work in multi-monitor setups and render in “borderless windowed” mode, so you can alt-tab out to multitask, or have a comms overlay. Single monitor single process gaming still happens, but a good 85% of setups (according to the Steam Hardware Survey) are not that. There are five games I know or that actually handle multimonitor natively of the hundreds I’ve played. So we need some form of cooperative multitasking for graphics with the window manager.
Started doing 50% this month, and for the first time in years I actually feel like I get stuff done outside work. Like, not just chores and a tiny bit of fun-coding once in a honeymoon, but really spending time on coding for fun, getting something done around the apartment, just going for a walk for two hours. All things I wanted to do or try but always felt too tired, or something more important popped up. Things like, just repainting part of a wall in one room got postponed for almost a year, and now that I did it, it didn't even take half an hour and actually felt good.

I'm still working three days a week, because it's not like I hated my job, but it was quite demanding at times.

I wrestled with the idea of just reducing hours for way too long. If you do too, just do it.
In the nightmare kitchen sink of web transpilers and meta-framework, yes just print it is often way more efficient than trying to make a sense of these useless stack traces, or set a brittle debugger configuration in your IDE that sooner than later will invariably lake a map to know what code it should show.
How can the on-call coverage be specified at hiring? Can the company guarantee that my team will never shrink or that the page rate won't increase?

What will financially encourage my company to stop paging me overnight if there isn't a labor cost to the company every time an on-call incident occurs?

> What if I get injured and my insurance only covers base pay?

Insurance payouts can be easily based on wages that include reported commissions, tips, and overtime. They can very easily be based on an average of past actual wages paid in the last handful of months at the company.

> Severance is usually based only on base pay

Severance is a completely optional practice that is based entirely on what the company wants to do. I would argue that severance is more accurately based on "The lowest safe number to pay to this particular employee to make sure their termination does not become a legal risk."

> I would not be paid on-call while I'm on PTO or other paid leave

But also, PTO days and on-call days don't indersect. If you took time off during an on-call shift you would be trading it with a team member, so you would never lose that extra wage.

Example: I'm taking a week off, it's during my scheduled on-call shift. I would normally get paid my on-call hours but I didn't this week. But when I get back from my vacation, I'm picking up an extra on-call shift because my team member covered my shift when I was on vacation.

Now, I'm taking a week off, but it's not during my on-call shift. I wouldn't have been paid on-call hours this week anyway. When I get back from my vacation, I am going on my normally scheduled on-call shift.

I personally have never felt compensated dynamically enough for on-call schedules. Most corporate jobs seem to pay for a sliver of the life disruption, maybe paying for half my phone and Internet bill or something like that. They all say that the on-call is baked into the compensation, but I'm not so sure.
Not exactly. More that Netlify started as a no-devops-needed static website hosting platform, and gradually branched off into value props that naturally fit into that starting point.

Vercel (formerly ZEIT) basically did the same thing.

Since founding, both companies have raised an insane amount of VC money, making them both unicorns by valuation a few times over. Though imo it remains to be seen if this was actually a good investment. Neither company seems to have fully made good on their business model, which is quite similar in both cases: encourage and allow devs (or non devs) to do the absolute bare minimum of work in exchange for hosting/bandwidth/etc prices that many consider exorbitant.
Can't this be solved to some sort of DP way of solving the sub problem?

Do the payout between 0 and 1 as the percentage of the amount.

With a range of 1 to 1 to pay off is obviously one

With a range of 1 to 2 the payout is .5

At three values it becomes more interesting. There are two strategies for the candidate either a binary search for the endpoints.

At four values you still have one level of binary search possible but after that it devolves down to the two value problem.

At five values. If the interviewer thinks the candidate would choose binary search and it becomes too too value problems on each side after removing the middle element.

There's definite problems with this but I wonder if he's already possible pay off matrix
> I assume it could have been made implicit

Not quite. It gets ambiguous whether to wrap return or not. Example:

function foo(): Promise<number> {
if (...) { return Promise.resolve(5) }
...
}

but async version is:

async function foo(): Promise<number> {
if (...) { return 5 }
...
}

Although you can bake into the language one way or another.