skysight-inc/HackerNews huggingface dataset:
The blog post does, at the very end, mention the thing you should actually do.

You need a language where you can express what you actually meant, which in this case is "Perform this constant time operation". Having expressed what you meant, now everybody between you and the hardware can co-operate to potentially deliver that.

So long as you write C (or C++) you're ruined, you cannot express what you meant, you are second guessing the compiler authors instead.

I think a language related to WUFFS would be good for this in the crypto world. Crypto people know maths already, so the scariest bits of such a language (e.g. writing out why you believe it's obvious that 0 <= offset + k + n < array_length so that the machine can see that you're correct or explain why you're wrong) wouldn't be intimidating for them. WUFFS doesn't care about constant time, but a similar language could focus on that.
I recently threw out the "do the MVP" mindset.

To me, MVP means "Do part A to a good enough level of perfection where customers will buy it, then release and get customers, support them while then working on part B as a value-add.." - often, in my mind, all parts, ABC add up to the whole package value. I don't want to break it apart.

I'm actually trying to do more planning and outlining first, and it has worked reasonably well for me.

Start with an outline of the different systems and how they connect, then outline one of those systems, the inputs and outputs to it. Then break down further into how does it get the input, where does it put the output, etc.

It has been remarkable in that I can actually feel joy for what I'm making again. I have also tried to start a blog with doing this type of "open design" - but blog writing requires its own planning and refining, which is an extra workload that I didn't intend to put on myself..
If you interpret anything as yelling it's disruptive. But I'm not sure why that would be the interpretation. It's a short preamble to the next sentence.
NASA states that solar magnetic field and related sunspot numbers have nothing to do with earth based mean temperature change:

Is the Sun causing global warming?

https://science.nasa.gov/climate-change/faq/is-the-sun-causi...

Why Variations in Earth’s Magnetic Field Aren’t Causing Today’s Climate Change

https://science.nasa.gov/science-research/earth-science/flip...

Your comment appears to based on some kind of psuedo scientific misunderstanding.
GenLaw: Metaphors
>> There are quite a few publications that explore the concept of generating programs, either using typed or untyped functional languages.

That's Inductive Functional Programming (IFP), a kind of Inductive Programming that also includes Inductive Logic Programming (ILP). The canonical example of IFP is Magic Haskeller:

https://nautilus.cs.miyazaki-u.ac.jp/~skata/MagicHaskeller.h...

As an example of a modern ILP I suggest Popper:

https://github.com/logic-and-learning-lab/Popper/

Or Louise (mine):

https://github.com/stassa/louise

One of the DreamCoder papers describes Inductive Programming as a form of weakly supervised learning, in the sense that such systems learn to generate programs not from examples of programs, but from examples of the target programs' beuav908rs, i.e. their inputs and outputs. By contrast LLMs or slightly older neural program synthesis systems are trained on examples that consist of pairs of (programming-task, program-solving-the-task).

Another way to see the difference between Inductive Programming systems and conventional machine learning systems used for program synthesis is that Inductive Programming systems learn by solving problems rather than from observing solutions.

The advantage is that, in this way, we can learn programs that we don't know how to write (because we don't have to generate examples of such programs) whereas with conventional machine learning we can only generate programs like the ones the system's been trained on before.

Another advantage is that it's much easier to generate examples. For instance, if I want to learn a program that reverses a list, I give some examples of lists and their reverse, e.g. reverse([a,b,c],[c,b,a]) and reverse([1,2,3],[3,2,1]) whereas e.g. an LLM must be trained on explicit examples of list-reversing programs; like, their source code.

IFP and ILP systems are also very sample efficient, so they only need a handful of examples, often just one, whereas neural net-based systems may need millions (no exaggeration- can give a ref if needed).

The disadvantage is that learning a program usually (but not always - see Louise, above) implies searching a very large combinatorial space and that can get very expensive, very, very fast. But, there are ways around that.
I assume they are reading down a list of unique clients they have identified. Pretend their is a hidden column containing IP addresses.

Some clients have the multiple entries because multiple people/companies will have installed the same software.
> But having a straightforward/predictable mapping to the underlying machine and its semantics is included in the C model of computation.

not rally, or at least not in a way which would count as "high level assembler". If it would the majority of optimizations compilers do today would not be standard conform.

Like there is a mapping to behavior but not a mapping to assembly.

Which is where the abstract C machine as a hypothetical machine formed from the rules of the standard comes in. Kinda as a mind model which runs the behavior mappings instead of running any specific assembly. But then it not being ambiguous and complete doesn't change anything about C not being high level assembly, actually it makes C even less high level assembly.
Well, Telegram is faster/smoother than FB Messenger, Whatsapp, Discord (dog slow) etc...

So it is not only working but working well.
Cloud-to-ground lightning strikes may have jumpstarted life on Earth
> Only x=0 is undecidable.

That cannot be true, because if both x<0 and x>0 are decidable then x=0 is also decidable.
>> The trick is not just synthesizing valid functions, but doing so in a parallel communication-free manner, without compromising soundness or completeness.

Right! A great way to do this is to learn a program by using it to prove the training examples while it is being learned. A very cool ability that some systems of the new wave of Inductive Logic Programming can pull off, but probably nothing else can far as I can tell.
StarBook 7 14" Linux Laptop with Intel Core Ultra 7, 4K, Up to 96GB 5.6GHz RAM
https://en.wikipedia.org/wiki/Sea_organ?wprov=sfla1
I highly recommend it. The docs describe it as a zen-like experience, and I fully agree. Once you get the hang of it, it makes it so easy to tweak the syntax of whatever language you’re building. I love it.
Huh! I wonder how the site I got that number from got the cargo capacity so wrong. Looks like the battery itself has a 100,000 mile/8 year warranty (whichever comes first) which is honestly longer than I expected.

Well, we’ll see in 5-10 years when she’s ready to replace the RAV4. She had to drive 300km for work today which looks like it would have been right on the edge of the range of that unit. Would’ve been cheaper in an EV, but a significantly longer day since there’s no high-capacity charging infrastructure available on the shortest route to get there.
So instead of just doing the rather fast elliptic curve math when getting a TLS connection request by using a standard crypto library, I’m supposed to call out to a cryptographic coprocessor that may or may not even support the operation I need? Have you seen what an unbelievable mess your average coprocessor is to use, Intel or otherwise.

CPUs have done just fine doing constant time math for decades. It’s at best a minor optimization to add data dependence, and Intel already knows (a) how to turn it off and (b) that it’s sometimes necessary to let it be turned off. Why can’t they add a reasonable mechanism to turn them off?
Multiplier v2: Code indexer specialized for C/C++
I was curious too, so I have ran the included benchmark for a 500x500 matrix and my naive Kotlin A* implementation runs faster on the same input. So what are we missing here?
Evaluating a class of infinite sums in closed form
What this all has in common is no one is engaging in a complex personal surveillance enterprise to target you, because they don't need to.

It's not even a $5 wrench scenario, because they don't care: the point of jack booted thugs is you simply apply force to every problem and potential problem, and dare anyone to stop you.
Sure, there are a lot of interesting and compelling angles to consider why these kinds of things happen. In such a specific case as the parent comment here, it really is more interesting in my opinion to see what was found.

For example, it stood out to the team that they group of people that were on the call paint a certain picture when considering how similar they were (specifically by surface-level factors like race or sex). Is that response justified when they dug in and found that the group didn't represent a similar makeup of the total population despite having completely ignore sex and race? Or did it turn out that the population is actually that homogenous? If it is that homogenous there are great questions to dig deeper on, like why that happened and what may be done to help correct that.
FAQ: Low-Level Exploitation
I think it depends on the domain. You don't need Rusts memory safety guarantees everywhere for everything. But if you're writing some sensitive piece of code where security is crucial, it seems crazy to not use a language like Rust.
<https://news.ycombinator.com/item?id=13531909>
To explain why it can be removed in the former:

Since it is UB to dereference a null pointer, the compiler can assume that ptr isn't null after it is dereferenced[1]. Therefore, the if condition will always be false.

In fact if ptr is null, unless the foo field has a very large offset, the behavior you would probably expect would be for the dereference to segfault before reaching the if, so it doesn't really matter if it is optimized away.
I haven't found a single good (working, easy to deploy cross-platform on CPU/CUDA/Apple Silicon) implementation of streaming + diarization, and I have looked at everything from WhisperX to pyannote to WhisperKit.

Any suggestions would be very welcome!
And post-Elon, every time:

Liberal: I have been censored for my liberal views

Me: Holy shit! You were censored for wanting higher taxes?

Con: LOL no...no not those views

Me: So....regulation?

Lib: Haha no not those views either

Me: Which views, exactly?

Lib: Oh, you know the ones

Oh how the turntables.
> Set a flag in the executable which requires that MSR to be enabled. Then the OS will set the MSR when it loads the executable, or refuse to load it if it won't.

gcc did approximately this for decades with -ffast-math. It was an unmitigated disaster. No thanks. (For flavor, consider what -lssl would do. Or dlopen.)

> Another option would be for the OS to expose a user space API to read that MSR. And then the compiler emits a check at the start of security-sensitive code to call that API and abort if the MSR doesn't have the required value.

How does the compiler know where the sensitive code starts and ends? Maybe it knows that certain basic blocks are sensitive, but it’s a whole extra control flow analysis to find beginning and ends.

And making this OS dependent means that compilers need to be more OS dependent for a feature that’s part of the ISA, not the OS. Ick.

Or maybe even, the OS could let you turn the MSR on/off on a per-thread basis, and just set it during security-sensitive processing.
Public keys and web of trust as a solution to content validity seems to be a strangely common misconception of what "authentication" actually means.

All you would get at very most is "this was vouched for by a human", not an actual guarantee of humanity.

Once the WoT grows past a certain point it will be of dubious value. Furthermore, people would happily "sell their souls" into signing off on any ole bullshit for money. Let alone doing it for free if they think their violence towards the truth would be ideologically aligned. Any attempts at curing it frankly may be undesirable due to being worse than the disease.
The problem is that the 'you' in 'if you interpret' is 'many (probably most) people reading online comments'. That's the point the mod comment is making. The effect counts rather than the intent.
Perhaps he was more concerned with job control, and saw centralized code as a detriment to his job security
This is better known as the Table Maker's Dilemma.

Say you have some computable number p, that means you can compute a (rational) approximation p' to p within any given tolerance eps > 0 (i.e. you know |p - p'| < eps). To determine whether p > 0, p = 0, or p < 0, you compute an approximation p' to a certain tolerance eps. If p' > eps then you know p > 0, if p < -eps then you know p < 0, otherwise you need a better approximation... Without further knowledge about p, there is no point where you can assert p = 0.
Fiddling some bits cross-platform is supposed to be one of them.
For my personal projects I use a very similar approach. However, I find this technique difficult to do with a group (more than 3 people).
Nope. You're thinking about this mathematically, not algorithmically. The question is essentially to decide whether the output of a TM is all zeros or whether it will eventually output a 1. If it outputs a 1 you will know that in a finite amount of time by running the program, but if it never outputs a 1 then you can't tell that by running the program, and it's impossible in general to tell any other way because that would be tantamount to solving the halting problem.

Here is a concrete example: write a program that systematically tests all numbers for counterexamples to the Goldback conjecture. Every time a number fails to be a counterexample, output a zero, otherwise output a 1. Consider the output of that program to be a real number expressed as a binary decimal. If that number is not zero you will know in a finite amount of time, but if it is zero you will not know that until someone proves the Goldbach conjecture.
> That's all most people that complain about optimizations on undefined behavior want

If this was true most of them could just adopt Rust where of course this isn't a problem.

But in fact they're often vehemently against Rust. They like C and C++ where they can write total nonsense which has no meaning but it compiles and then they can blame the compiler for not reading their mind and doing whatever it is they thought it "obviously" should do.
Reading the Mistborn trilogy has made me happy in ways that are hard to quantify.

The first book drags in the middle, and the trilogy as a whole drags in the second book, but they're not impossible to read
I would also add in California’s case that California isn't that liberal/progressive

Its conservative laws get struck down by the 9th circuit and its progressive laws stick

could probably just move the 9th circuit courthouse out of San Francisco and everything would drift to centrist quickly
https://archive.ph/KIeBP
The “50%” point is the median. So, the point at which it is just as likely to have happened as to not have happened. The mean will in general be different from the median if the distribution is skewed. Here the mean is pulled a little higher than the median by a few years with a “long tail” of estimates in the later years. The distribution can be seen in figure 4(b)
In case anyone is curious about what the proper solution to some of these problems is in modern SQL Server:

1) Many columns can happen with per-customer customisations to a shared table. The common way is to have a "customcolumns" table with "ID,ColumnName,ColumnValue" linked to the base table that has an "ID" key, but SQL Server also supports this natively now with Sparse Columns: https://learn.microsoft.com/en-us/sql/relational-databases/t...

2) Shared identity or globally sequential numbers have a built-in schema object type now: https://learn.microsoft.com/en-us/sql/t-sql/statements/creat...

3) Manually populated calendar tables are actually a common schema design pattern, especially in manufacturing, shipping, and OLAP reporting systems. This is not that bizarre, it's just a bit weird that it would break logins! These tables can let you define all sorts of things such as international holidays, manufacturing calendars, tax years, finance reporting schedules, etc...

4) Dropping and recreating tables is also common, albeit usually done in a transaction. The fancy way to do this is with partition switching, where a new table is populated from whatever (external data, business logic, etc...) and then instantly swapped for the original without any long-running operations like truncate & insert would. See: https://pragmaticworks.com/blog/table-partitioning-in-sql-se...

5) Delayed reporting replicas ("here was a copy of the database. Data in this copy was about 10 minutes out of date.") is also a common pattern. At this point, the blog author is just complaining about the realities of business databases. Typically you'd have a bunch of read only replicas with different delays: Synchronous for HA failover, Asynchronous for DR failover and real-time reporting, and deliberately delayed on a schedule ETL copies for "point in time" consistent reporting. These would typically be done at 3am or something to minimise inconsistencies in the data. The modern way to do this is a SQL Server Always On readable secondary: https://learn.microsoft.com/en-us/sql/database-engine/availa...

6) "The main codebase I worked in was half VB, half C#." this is also surprisingly common. It's often not worth rewriting old code, there's not enough return on the invested money. These days there are automated conversion tools for VB to C#, such as: https://marketplace.visualstudio.com/items?itemName=SharpDev...

7) The Gilfoyle character is honestly the only thing that stands out here as an actual problem, not just a typical thing that happens in large enterprise bespoke software development.
LLM as Database Administrator (2023)
Just as a total pedantipoint, they also do that in binary (hence the B in BCD, in that specific case).
I sure hope it honors fsync!
Nvidia reportedly delays its next AI chip due to a design flaw
I do that in a similar way. I start doing all parts at the same time, going back and forth until it’s done. It’s not a perfect approach though. Two downsides I sometimes encounter are: dependency, when most or some of the work or scope depends solely on perfecting another part, and if the work is complicated, you can get extremely overwhelmed to the point you don’t know where to start or even start at all.
They still have valid use cases like backups or unedited video footage. It's just kinda lame that the manufacturers don't market them as "slow backup devices" clearly listing all limitations, and that you have to find it out first time you use it.
I said so upthread, Harlem River House is the model. Government building out large and livable housing.
Don’t think so. My first job was kind of like that. I don’t even know how they thought that little old me just out of university could be left alone to successfully build applications on my own, but I think people trusted a lot more during that era because eternal september hadn’t arrived yet.

Working directly for the users without any weird BA/PM/TA shit in between is glorious, both because you can always walk up to get immediate feedback (people generally like to see you are actively working on their issue), and in a place like that you can likely deploy it in the middle of the day and immediately improve their workflow.

It still amuses me that IT was located together with finance, because we did reports xD
I was like "what's the hair security trick?", then proceeded to learn how tricky it is to Google for anything hair + security related, because it's flooded by wig securing techniques..

> Close your door and stick a single hair across the gap - so you will know if anyone went in.
I've seen those stickers on hard drives. I always assumed that maybe the internal mechanisms were in a vacuum or super-clean and opening the case would allow air or dust into the moving parts.
> has ignited widespread speculation about the extent of the breach and its implications for the global financial system.

> after generating discussion on Hacker News.

There are no comments on the story in the photo. Nor when it is searched on HN (when the same OP posted it two months ago).
Not too interested in the course but, I found the instructor's essay interesting.

https://www.scottaaronson.com/papers/philos.pdf
What a great reading list.
OTOH, if you can get treesitter to work, all the best editors will gain Protobuf support.
Its trickier to scale for sure. I have actually seen something very similar work really well at an early startup. The team was around 5-6 people and fully remote at the time.

The real key is communication and trust. It only worked well for us because we communicated frequently, the CTO/lead was really good at acting as a conduit between everyone working on related projects, and we all really offered each other the trust to let each other run with it and adjust on the fly.

It was really common for us to go into a week with a clear idea of what the next feature to build was, only to end the week with the person working on it finding a different path or a reason not to build that at all, often with an alternative to propose. We'd discuss it as a team when needed, but it was always clear that the person who was working on it was the expert on it at the moment and had a lot of sway in direction for that feature.

It isn't easy, and it did actually fall apart when the team scaled to 10+ people, but there may have been ways we could have adjusted and avoided that too.
> "There may be a path forward" -- weasel words.

Or, humility. Nothing is certain in civic planning. But I suspect you'd jump on me if I claimed it was a foolproof plan, wouldn't you? But it's observed all over the world: in places where housing is affordable and available, there isn't a homelessness crisis. Most homeless people don't wanna be. Remove them, and the community goes away, and with it, all but a very few diehards that exist in practically every city.
> plenty of Americans would say the same thing verbatim, too, without literally assuming the existence of one police force

They're also wrong to do so, because police forces vary widely by jurisdiction and cannot be generalized. I don't only object to people from other countries doing it, it's just particularly uninformed when they do.

I say this as a resident of a small city with a police force that has never had any controversy whatsoever, but whose officers feel acutely the generalized hatred directed at everyone in blue that has become vogue in a large segment of the country.

Just because your police forces are awful doesn't mean they all are.
And how many of those people programming in 2000 left during the dotcom crash and never came back? That would line up with my anecdotal experience of seeing a huge drop off for people past age ~45
True. The mess comes from a son reheating food, often tomato sauce based, without a lid.
im gonna try this out over the coming weeks and report back

this could be the most powerful thread ive come across on HN
I thought there was another 70's screen-free arcade game discussed on HN in the past year, but I've failed to pull it up. At first I thought this article must be about the same thing.

Can you help me remember?
Here is an article by Rahmstorf that roughly corresponds to his talk (for those who prefer that to a video): https://tos.org/oceanography/article/is-the-atlantic-overtur...
I wouldn't have guessed Game Informer was still around. Growing up, I felt it was like the little brother of GamePro and Electronic Gaming Monthly, both of which published much bigger issues.

But my parents were frugal, so Game Informer was the first magazine subscription I ever had. I credit it with greatly improving my reading skills by exposing me to journalism.