skysight-inc/HackerNews huggingface dataset:
I have a perfect solution for this, that works for me at least.

Adding a `..` to the end of a variable triggers a macro that changes `val` into something like `print("val:", val) // FIXME: REMOVE`. Then a pre-commit hook makes sure I am unable to commit lines matching this pattern.
Tom Holland Visits the Campus School at Boston College
Europe is in many respects more market oriented and capitalist compared to the US. This is entirely not the issue.

And, I'm not sure why I need to spell this out to you, but both public and private life in Europe run on money that has to be generated by a healthy economy, which, we cannot expect, when Europe stops being competitive with respect to the US and China.

Thinking this is just about tech salaries is very first order thinking.

EDIT: Maybe I should add some context, and I'm sorry if I come off a bit condescending in my reply to you. We are facing governments who have no clue how to solve our economic woes, but who certainly have a plan on how to act: austerity measures. So all those nice things you associate with the European economic model are precisely the things that might cease to exist.
That's not the E editor he talked about. It is the editor created by Richard Hipp himself. You can find a reference here:

https://wiki.tcl-lang.org/page/Tcl+Editors

And you can find a version here:

http://grumbeer.dyndns.org/ftp/cdroms/freebsd/freebsd-2.2.1-...
It's been a long time since I read it, but my takeaway was that he was depicting the true nature of humanity. Specifically, that people are neither fundamentally good or evil, but are fallible beings that react to their circumstances.
> Customers believed the accounts were backed by the full faith and credit of the U.S. government.

Let's just hope that the U.S. Government doesn't bail out people who gambled on sketchy investment schemes. With a renewed push for "crypto" my big fear is us Taxpayers will be bailing out everyone's 401ks in 4 years.
Fighting the Urge to Girl Nap Until Spring
There is no “European PhD system” in terms of funding, or the duties expected of a PhD student other than the production of the dissertation. Different countries around the world do it differently, and that is true even within Europe.
Speaking from my own experience I'm not so sure that printf debuggers just have "incomplete knowledge [...] of modern debugging tools". I use printf (or the file-based equivalent, log files) quite a lot, but nobody can accuse me of not knowing good debugging environments.

Also, what's "modern" about "Walk the call stack! See the parameters and values, add watches, set conditional breakpoints"? Those are all things we had many decades ago (for some languages, at least). If anything, many modern debugging environments are fat and clunky, compared with some of the ones from way back when. What has greatly improved though are time travellers, because we didn't use to have the necessary amounts of memory lots of the time.

So please refrain from calling people with different preferences uneducated. [Ed. I retract this bit, though I think it is not unreasonable to associate lack of knowledge with lack of education (not necessarily formal education!) I don't want to quibble over semantics.]
Also: they need top tier models for their Bedrock business. They are one of only a few providers for Claude 3.5 - it’s not open and anthropic doesn’t let many folks run it.

Google has Gemini (and Claude), MSFT has OpenAI. Amazon needs this to stay relevant.
Is this peak bike-shedding?
I love your work, especially browserquest!
As I recall, the ZX81 came as either a kit (mail-order) or pre-built. My first computer was a pre-built ZX81 bought from WHSmiths.
Another thing I think leads people to print debugging - which is both a strength and a weakness of the approach:

It minimises the mental effort to get to the next potential clue. And programmers are naturally drawn to that because:

1. True focus is a limited resource, so it's usually a good strategy to do the mentally laziest thing at each stage if you're facing a hard problem.

2. It always feels like the next time might be it - the final clue.

But these can lead to a trap when you don't quickly converge on an answer and end up in a cycle of waiting for compilation repeatedly whilst not making progress.
There was a project to add flood prevention dams in the area but it was blocked for 20 years by the party in power. And it was from their own party's campaign promise. Also, the cleanup of existing dams and rivers was blocked due to environmental reasons. And the EU government was backing all this. At least most of Valencia was spared due to works made over 50 years ago.

I don't believe the mainstream whitewashing of authorities. Administration openly against dams and waterworks, no alerts due to malfunctioning radars, terrible coordination, and lack of appropriate response.

Source: I personally know people from the affected area.
Nothing is free. In this case, the Support page seems to imply that this runs free thanks to donations and volunteering, and some time-bounded (and finished) contributions from public actors.

I would kindly ask anyone stating that they provide a service for free, to explain exactly how they are planning on financing it, and for which amount of time, so that users can decide how much trust to place on its survival, and how risky it is to build a dependence on it.
Yummy cookies across domains (2019)
I think that persistence of print debugging shows weaknesses of debuggers.

Complicated setup, slow startup, separate custom UI for adding watches and breakpoints.

Make a debugger integrated with the language and people will use it.

You can then pile up on it subsequent useful features but you have to get basic UI right first. Because half of programmers now are willing to give up stepping, tree inspection even breakpoints just to avoid dealing with the crappy UI of debuggers.
In ten years maybe we'll know.
That's table stakes for a programming language these days I think.

JS: debugger;

C#: System.Diagnostics.Debugger.Break();

Rust: std::intrinsics::breakpoint();

Go: runtime.Breakpoint();

Zig: @breakpoint();
> used a ViC20 in a department store to learn coding

How long did you spend in that department store? How did you charm the personnel into letting you keep at it?
Julia and Python Comparison: summing a series
> I only have time to listen to audiobooks

RTO commute has me listening to audiobooks again, or as my kids call them “Read-A-Louds”
Ways to Use Feature Flags for Smarter Releases
As a ColdFusion developer (it still pays the bills) I've been doing this forever as Adobe has never really built a good step debugger. Their latest IDE has one but it's very difficult to setup and is buggy when it does work. BoxLang is modernizing CFML (among other things) and has a nice, working step debugger... https://boxlang.io/

It's always so weird to switch to another language which DOES have a debugger...
It should be a protected term in advertising. As soon as you use it, you surrender yourself to FDIC auditors.
Yes, but with sqlite there is much less ceremony (no server, etc.) and most importantly can be used without talking to my institution's sysadmin, which is what I'm looking for when manipulating one-off datasets.
How well can LLMs see?
The account may be a loss leader for them. It's definitely a legit bank; used to be owned by TIAA, and was called TIAA Bank for a while. They've tracked the fed rate for the whole year, so it's not a special temporary deal. The current rate only applies to new accounts; no idea how well established accounts track the rate.
FWIW if you're stuck on command line GDB it can be worth learning about TUI mode - "layout tui" which gives you side by side code and debug console.

It makes command history not work by default but IIRC "focus cmd" fixes that.
The article mentions it, but you can sum up print debugging as selectively enabling verbose/trace logging. “We’re about to do X” or “We just did Y, here is Z”.

A debugger gives you insight into the context of a particular code entity - expression, function, whatever.

Seems silly to be dogmatic about this. Both techniques are useful!
I would rate it 25/100.

That's only because of the battery.

The lid angle sensor is insulting. Screen swaps shouldn't have the issues they do.

Apple needs to do better.
> the reason there are a lot of articles dissuading the practice is the observed reality that people who lean on print debugging often have incomplete knowledge of the immense power of modern debugging tools.

While perhaps this is true of some sort of junior developer, I have both written my own debuggers and still lean heaviest on print debugging. It's trivially reproducible, incurs basically zero mental overhead, and can be reviewed by another person. Any day I break out a debugger is a bleak day indeed.

Profilers are much easier to argue for as it is very difficult for one to produce equivalent results without also producing something that looks an awful lot like a profiler. But in most cases the mechanisms you mention are just straight unnecessary and are mostly a distraction from a successful debugging session.

Edit: in addition to agreeing with a sibling comment that suggests different problems naturally lend themselves more to debugging (eg when writing low-level code a debugger is difficult to replace), I'd also like to suggest a third option languages can take: excellent runtime debugging ala lisp conditions. If you don't have to unwind a stack to catch an exception, if in fact you can modify the runtime context at runtime and resume execution, you quickly realize the best of both worlds without having to maintain an often extremely complex tool that replicates an astonishing amount of the language itself, often imperfectly.
Note the "Backed by YCombinator" on their web page:

https://web.archive.org/web/20200630201639/https://www.withy...
To be fair at least, I think in c# one should avoid Console.WriteLine as much as possible, because Console.WriteLine is blocking which make API request slow and instead use logger like serilog and use async sinks
Print debugging is a disaster. If there's one widespread practice among non-beginner developers that wastes hours of time it's print debugging. I honestly can't tell how often I have seen people, even experienced programmers (usually because they insist on running some bespoke vim setup) refuse to use a graphical debugger to actually step through a program, and instead they spend hours hunting down bugs they could have found in ten minutes.

There's a section of an interview with John Carmack (https://youtu.be/tzr7hRXcwkw) where he laments the same thing. It's what the Windows/game development corner of the programming world actually got right, people generally use effective tools for software development.
Telomere length is dynamically regulated. It sounds like SCNT does well at triggering the correct reprogramming to reset epigenetic features that might have led to Dolly's troubles (although it seems these were greatly overstated: https://blog.cirm.ca.gov/2016/07/27/cloning-breakthrough-dol...)
FWIW I (author) didn’t want to mock functional programming. I consider myself an aficionado of functional programming patterns :)
Amdahl's Law is one of my favorite things from college. It's general principle, optimize the largest parts of a project for the biggest impact, is applicable across more than just programming. I've used it to help prioritize tasks within projects, both professional and personal, that have little-to-nothing to do with programming, and decide where to optimize project costs.
It's basic algebra. Calculus would involve derivatives or integrals.
For anyone that wants to buy the 139 megapixel image for printing, it's $50 here: https://cosmicbackground.io/products/fusion-of-helios

I'm not affiliated, but I've been seriously debating it for a long time. The photo is a composite of the sun and the sun's heliosphere from the 2017 eclipse. One of my favorite images of the Sun.
Have a look at Langroid [1], a multi-agent LLM framework from CMU/UW-Madison researchers (I am lead dev). It does not use any other LLM library (CrewAI uses LangChain). We started building Langroid in Apr 2023 as an agent framework from the ground up, with a particular focus on an agent orchestration mechanism that seamlessly handles inter-agent hand-off as well as Tool/Function-handling.

[1] https://github.com/langroid/langroid
Yeah it's a big enough pain point that I'm sure it's been done in at least some places. I'm not really sure it'd be worth the bother and memory consumption etc to set up though. Not when print is dead simple and works everywhere.

More like regular debuggers, it seems to me like it's something to set up only when print debugging just isn't getting the job done and you think you need something extra to help solve the problem.
Similar vibe to showing office workers how to use Vlookup in Excel. Or fields in Word.
I guess a good example is things like the physical characteristics of a line drawn by the stroke of a paint brush. You can often see they all align generally in the same direction, and have a sort of "fingerprint"
Link since OP didn't provide it: https://www.topyappers.com/
It got put in vs code so mediocre developers can finally use it. Like all things they cargo cult it because they don't know how to use it properly.
I'm a CS professor teaching some programming courses. I always make an effort to teach my students how to use a debugger and encourage them to use it, because otherwise they will not even try (print debugging comes naturally, while using the debugger requires more effort). I want them to master it so they can make conscious decisions about what to use.

Then, when I code myself, I use print debugging like 99.9% of the time :D I have the feeling that, for me, the debugger tends to be not worth the effort. If the bug is very simple, print debugging will do the job fast so the debugger would make me waste time. If the bug is very complex, it can be difficult to know where to set the breakpoints, etc. in the debugger (let alone if there's concurrency involved). There is a middle ground where it can be worth it but for me, it's infrequent enough that it doesn't seem worth the effort to spend time making the decision on whether to use the debugger or not. So I just don't use it except once in a blue moon.

I'm aware this can be very personal, though, hence my tries to have my students get some practice with the debugger.
Wyoming Stable Token Commission
It appears that Wyoming is looking into creating their own USD-backed stable coin. They've narrowed the choice on where to host it down to a small number of public blockchains.

It isn't clear to me how this benefits the people of Wyoming, or why it makes any sense for a US state to issue their own stable coin, but I'd love to hear thoughts from others.

Here are the potential chains:

Solana, Sui, Ethereum (inclusive of Polygon, Arbitrum, Base, and Optimism layer-2 networks thereon), Avalanche, and Stellar.
They are de-facto banks. Laypeople cannot understand the difference, and these fintech services use that confusion to amplify their reputation. It is manipulative.

We need a Nutrition Facts label for places you put your money.
Debugging with print has one feature that debuggers will never match. You can send the binary or code with print/log statements to someone else who is experiencing the problem and get them to run it.

Often I have to debug bugs I can't reproduce. If method 1 - staring at the code - doesn't work, then it's add print/log statements and send it to the user to test. Repeat until you can reproduce the bug yourself or you fixed it.
I trust them a whole lot more than any random fintech company. At least with traditional banks, there is some amount of protection available.
Looks exactly like Premium Bonds here in the UK. (Winnings on those are also tax free, not sure if yours are the same.)
That's why I think it's imperative to help Ukraine. Because if Ukraine loses in a year you'll have:

- Iran suddenly pops out with nukes;

- Then Saudis will show off their own nuclear deterrence;

- South Korea will need to have nukes against NK and Russia;

- For sure Poland doesn't want to be left hanging out to dry with Trump, so for sure they'll get it;

- Germany might as well do it;

- Vietnam if they can develop it;

- Baltic states might make a coalition to develop nukes;

- Japan?
Have you ever been able to try https://replay.io time travel debugging as an alternative to conventional logging?

Last time I tried it you were able to add logging statements "after the fact" (i.e. after reproducing the bug) and see what they would have printed. I believe they also have the ability to act like a conventional debugger.

I think they're changing some aspects of their business model but the core record / replay tech is really cool.
Even with this hand-picking I got 70% and am nowhere near an expert on either AI or human art, having dabbled in it for a day or two back when DallE and Midjourney first became popular. I'm sure someone who's into the image generation field could score 80%+ consistently even over a larger dataset just as handpicked as this one.

Telltale signs of AI:

- Cliches. "Punk Robot" is a good example, a human artist capable of creating that would've somehow been more creative.
- Obviously facial expressions and limbs are telltale signs, very uncanny valley
- If there's an accurate geomtric repeating pattern, it's extremely unlikely to be AI. Something like "Giant Ship" is afaik still practically impossible to generate.
- Weird unfinished parts of a world. See "Leafy Lane". Why is there a vantablack hole at the end of the road? It's not physically impossible but it makes little sense and a human wouldn't put it there in that painting.
There are no good debuggers. They all lack a simple feature of what was the value of given watch in all subsequent calls and in context of values of other watches.
You should consider performance/efficiency at all stages. And that consideration should be based on an informed feedback loop where assumptions are validated and proven empirically. What developers think are performance patterns often wildly diverges from reality.

The scenario I gave is when there are performance problems with a developed project (you know -- where a profiler is actually usable, after they already decided on an approach and implemented code) and the developer is effectively guessing at the issues, doing iterative optimize-this-part then run and see if it's fixed pattern. This is folly 100% of the time. Yet it's a common pattern.
I hate that. It turns the problem into one of those lateral thinking puzzles we were told some basic information and then the answer winds up being something totally wildly different. It wasn't being very random in the end not being very productive
I agree and why would anyone use this over just buying a gift card from bitrefill, etc.
> Yotta marketed itself as a "bank" where every time you deposited to savings you would get a free lotto ticket for the month based on how much you deposited.

The archive link shows something a little more nuanced than Yotta presenting as a bank.

The archive link in gp has a hero text that says “banking” and then a few lines down says:
Yotta is a financial technology company, not a bank. Banking services provided by Evolve Bank & Trust and Thread Bank; Members FDIC.”

If I’m reading this as a consumer I’m thinking my money is protected but this Yotta thing is a lottery incentive to put deposits into those banks, maybe some loyalty incentive or marketing scheme on top of it?

Lesson learned, don't trust “not a bank” to deposit your money into the bank for you.
Hackers Breach US Firm over Wi-Fi from Russia in 'Nearest Neighbor Attack'
The Message by Ta-Nehisi Coates

I liked how it connected dis-connected stories and extracts a truth or message from observing each situation
I think this depends a lot on whether you're already using high level languages and lots of external libraries vs doing lower level programming using something like C/C++. I managed a large dev team in a Microsoft shop and it would never have occurred to anyone to ever create their own compiler. Even the most experienced programmers would have just continued to brute force things atop .Net's compiler until it eventually "worked". The result, combined with esoteric and poorly understood business requirements, was fragile spaghetti code few could parse for bugs or updates, but it was still several layers above the compiler.

This attitude is by far the most common among "enterprise developers", and one of the big differences between people building things from preexisting building blocks vs -- as witnessed from my 8 years at Google later -- people who think they're smart enough to build everything from the ground up, and do so, using primitive blocks and custom compilers created by similarly hubristic engineers who came before them.

Ymmv, but this has been my experience over the past 25 years.
> They do measure and report on this, both in summary in the blog post and in more detail in the paper.

I didn't see this in the blog post, where is it? Presumably they omitted it from the blog post because the results are bad as I describe below, which is precisely why I cited it as a red flag.

> If you can perfectly accurately extract the state the result would be pretty boring to show right? It'd just be a picture of a board state and next to it the same board state with "these are the same".

But they don't! They have nearly 10% tile level error on the human-data-trained model. That's nearly 100% board error. It's difficult to understand how bad this is but if you visualize it somehow (for example sampling random boards) it becomes obvious that it is really bad. On average about 6 or 7 tiles are going to be wrong. With nearly 100% probability you get an incorrect board.

> If you can extract them, they are encoded in the activations. That's pretty much by definition surely.

No, that's silly. For example you can cycle through every algorithm/transformation imaginable until you hit one that extracts the satanic verses of the Bible. As I said in another comment although it is in theory mitigated somewhat by doing test/validation splits in practice you keep trying different neural network hyperparameters to finesse your validation performance.

> How so? Given a sequence of moves, they can accurately identify which state most of the positions of the board are in just by looking at the network. In order for that to work, the network must be turning a sequence of moves into some representation of a current board state. Assume for the moment they can accurately identify them do you agree with that conclusion?

What conclusion? I believe you can probably train a neural network to take in board moves and output board state with some level of board error. So what?
When I was a postdoc in Cambridge, the problem was that there were too many PhD students and postdocs who wanted to teach. Not because of the compensation but for the experience. A lot of people wanted to try a career in the academia, and they needed teaching experience for that. But there were not enough undergraduates for them all to teach.
Notably, they promoted this scheme to people with troubled finances and tried to morally justified it by talking about how they were encouraging people to save their money who otherwise wouldn't. In principle that sounds good, but the reality is they just funneled those people into a glorified casino.
You can do something equivalent with time travel debugging since you can get the user with the problem to record, then ship you back a recording (or, if they don't want to, send them a debugger script to extract the logging you want).
Debuggers present you a single moment of execution but print debugging presents you the entire history of execution of relevant fragment all at once.

Create a debugger that has easily accessible history of execution and we can talk.
Crunchy Data Warehouse: Postgres with Iceberg for Analytics
It’s still a photo of the sun, even if processed. You wouldn’t see much on an unprocessed photo of the sun..