MurphyA/hacker-news huggingface dataset:
by johnnyanmac | 2025-10-18 20:35:45+00:00
Maybe this was more of an intro/pitch to something I already support, so I wasn't quite the audience here.

But I feel that talking about the open social web without addressing the reasons current ones aren't popular/get blocked doesn't lead to much progress. Ultimately, big problems with an open social web include:

- moderation

- spam, which now includes scrapers bringing your site to a crawl

- good faith verification

- posting transparency

These are all hard problems and it seems to make me believe the future of a proper community lies more in charging a small premium. Even charging one dollar for life takes out 99% of spam and gives a cost to bad faith actors should they be banned and need another dollar to re-enter. Thus, easing moderation needs. But charging money for anything online these days can cause a lot of friction.
by flashgordon | 2025-10-18 20:37:00+00:00
Pardon the delay. Love this analysis. I think you were the person who's particle system post that inspired me to give wasm a deeper look (as I was saying mine is just turn based games so not exactly a demanding workload).

My thought was - can I take a language that I am comfortable with and is reasonable fast (both to develop and from perf persepective) and use that as my "logic layer". C and Rust would also have been great but for me C's memory management (Id be lying if I said I am comfortable after being away for over a decade) and battery-light standard library (again not sure what changed in last 10+ years) kept me at Go (Rust learning curve I did not even want to think about).

Back to the performance penalties - I structured it so that payloads are small and all state is kept on the wasm side with just batched messages to update view state. If I ever need to do do high FPS things il have to dig more into SharedArrayBuffers (but felt this was pain to get working). But then Id have reimplement a lot of the libs like phaserjs etc?
by johnnyanmac | 2025-10-18 20:38:22+00:00
This website uses cookies, localStorage, sessionStorage, IndexedDB, WebSQL, browser fingerprinting, canvas fingerprinting, and probably your mom's maiden name to track literally everything you do. We share this data with 847 trusted partners including but not limited to: advertisers, data brokers, that sketchy startup in the Caymans, and anyone willing to pay $0.003 per record. By clicking "Accept All" you agree to let us sell your data. By clicking "Reject All" you agree to let us sell your data anyway. By clicking "Customize" you get to pretend you have a choice while we still sell your data. Someone asked where the cookie banner was. Here you go.

Perfect
by t43562 | 2025-10-18 20:38:30+00:00
Tests are how one constrains dynamically typed programs to make sure they work as expected. I have found that adding tests to untyped python code is far better at exposing bugs than adding typing is. I like my IDE to do completion too but I tend to add typing where I think it helps most rather than everywhere.

It just seems that some people like static types and good for them. Dynamic languages are for those of us who are, perhaps, lazy and want to be free to think about how to solve the problem at a slightly higher level without having to get into details.

For me the details activate my perfectionism and that blocks me from advancing with thinking about the goal and the effort of creating an elegant set of types makes me less willing to suddenly throw everything away when I realise there's a better approach. Dynamic languages give me that ability to "sketch" until I have an answer and at that point I have to ask: do I really need this to be in a higher performance language? Once or twice the answer has been yes but working out the approach in a dynamic language allowed me to do it right in the static language first time.
by MaxBarraclough | 2025-10-18 20:39:39+00:00
> This is literally what NULL is for. It's a special value precisely because missing data or a N/A field is so common.

Kinda. You need null for outer joins, but you could have a relational DBMS that prohibits nullable columns in tables. Christopher Date thought that in properly normalised designs, tables should never use nullable columns. Codd disagreed. [0]

> If you're suggesting mandatory additional has_address and has_customer_id fields, I would disagree. You'd be reinventing a database tool that already exists precisely for that purpose.

The way to do it without using a nullable column is to introduce another table for the 'optional' data, and use a left outer join.

[0] https://en.wikipedia.org/wiki/First_normal_form#Christopher_...
by itsnowandnever | 2025-10-18 20:40:19+00:00
etcd is also the entire point of k8s. that it's a single self-contained framework and doesn't require an external backer service. there is no kubernetes without etcd. much of the "secret sauce" of kubernetes is the "watch etcd" logic that "watches" desired state and does the cybernetic loop to bring the observed state adhere to the desired state.
by ekhaliul | 2025-10-18 20:40:47+00:00
Its probably more to do with demographics for EVs. Currently EVs and infrastructure around it cover mostly higher income brackets that do not want to bother too much with used cars, so the market around used cars is fairly small compared to ICE that cover both high and and lower end incomes. If you are in a bottom 50% and need a family car EV is still a significant financial risk. Once EVs cover lower income brackets we will see a much healthier used car market.
by appreciatorBus | 2025-10-18 20:42:02+00:00
Imagine a purely collectivist society. All land, all structures, all buildings, all homes, are controlled by govt or non profit or coop or whatever. All rents in all homes in all locations are set at $100/month.

Over time the leaders of the vanguard notice waitlists for decent accommodations growing longer in some places and they resolve that they must take action.

3 possible solutions are presented to the revolutionary committee:

- waitlist freeze - if the average waitlist for a home of a given size, for $100/month, in a given city is now 20 years, simply dictate that it is now illegal to offer housing with a waitlist of longer than 20 years. (or 10 years or five years or whatever) Facing prosecution for too long waitlists, operators start finding reasons to kick people off, or find reasons not list openings at all.

- Hokou - simply tell the ppl they are not allowed to choose where to live. If there is an available shack on the side of a highway in New Mexico, tell the New Yorker who just had a baby to move there (or tell someone else to move to make room). If it is difficult to build enough housing in New York, then simply build it somewhere else and have a committee dictate who has to move away from their family/friends/job/school.

- abundance - build enough housing in any given location to accommodate the entire waitlist to live in that location at $100/month and then some. If after that, yet more ppl sign up to live there or nearby, keep building until the waitlist is as close to 0 as practical. This takes time and the construction and disruption will annoy incumbent comrades who already have nice homes in good locations.

I can’t predict what the wannabe revolutionaries in the DSA would do in this scenario, but the historical track record of mass collectivization is not reassuring. I would take their arguments a lot more seriously if they were willing to talk about unintended consequences, and 2nd/3rd order effects. However, I feel like they only ever operate on the surface – simply decide the outcome you would like and say, “make it so“.
by tomjakubowski | 2025-10-18 20:42:49+00:00
Sometimes this kind of thing happens after a few revisions of code, where in earlier versions the structure of the code made more sense: maybe several conditions which were tested and then, due to changing requirements, they coalesced into something which now reads as nonsense.

When making a code change which touches a lot of places, it's not always obvious to "zoom out" and read the surrounding context to see if the structure of the code can be updated. The developer may be chewing through a grep list of a few dozen locations that need to be changed.
by coryvirok | 2025-10-18 20:42:55+00:00
Not sure why there is so much hate on this thread. I found the post well written, insightful, and pragmatic.

Having built systems that process billions of events and displayed results, triggered notifications, etc in real time (not RTOS level, I'm talking 1 or 2 seconds of latency) you absolutely need to separate reads and writes. And if you can trust db replication to be fast and reliable, you can indeed skip distributed locks and stay on the right side of the CAP theorem.

Event sourcing is how every write ahead log works. Which powers basically every db.

Is the concern on this thread that they preoptimized? I thought they walked through their decision making process pretty clearly.
by peterfirefly | 2025-10-18 20:43:27+00:00
Yang got out before Mao. China managed to birth and educate several world-class mathematicians and scientists in the short span between the beginning of Westernized education and Mao's take over... and then it stopped for several decades. The lucky ones managed to get out.

Strange to think that revolutions, unrest, the Sino-Japanese war, and the civil war all provided better conditions for fostering top talent than Mao's China did.
by kristopolous | 2025-10-18 20:43:31+00:00
huh I guess abstractions can lead to a break in consensus. You sound as confident as I feel on the matter but we're at different places.

Maybe that's all that "good design" is ... surely there's other systems and architectures where we can confidently reach the same conclusion independently.

For instance, here, I thought we have a well-done separation of concerns that is a bit exotic and people refuse to understand it.

However, as I explored how I disagreed with you, I realized that there's obviously messy concepts that I map differently than you do. So in truth we have an ambiguous design! I'll have to think about this some more.

Maybe usability issues arise not from tools that are "difficult" to use but tools that don't afford a clear mental model on their fit and purpose.
by kazinator | 2025-10-18 20:43:32+00:00
Answerable by a few minutes of googling. Sort of:

puts is a method which has a class: the Method class:

irb(main):001:0> method(:puts) => #<Method: main.puts> irb(main):002:0> method(:puts).class => Method

Everything being a confused muddle in Ruby, there is evidently some Kernel base class that is injected into every Object, and puts is a private method in that:

irb(main):003:0> 3.puts() Traceback (most recent call last): 2: from /usr/bin/irb:11:in `<main>' 1: from (irb):3 NoMethodError (private method `puts' called for 3:Integer)

The Method class of puts is a real class with methods and all:

irb(main):004:0> method(:puts).class.methods => [:allocate, :superclass, :<=>, :<=, :>=, :==, :===, :autoload?, :autoload, :included_modules, :include?, :name, :ancestors, :attr, :attr_reader, :attr_writer, :attr_accessor, :instance_methods, :public_instance_methods, :protected_instance_methods, :private_instance_methods, :constants, :const_get, :const_set, :const_defined?, :class_variables, :remove_class_variable, :class_variable_get, :class_variable_set, :class_variable_defined?, :public_constant, :freeze, :inspect, :deprecate_constant, :private_constant, :const_missing, :singleton_class?, :prepend, :class_exec, :module_eval, :class_eval, :include, :<, :>, :remove_method, :undef_method, :alias_method, :protected_method_defined?, :module_exec, :method_defined?, :public_method_defined?, :to_s, :public_class_method, :public_instance_method, :define_method, :private_method_defined?, :private_class_method, :instance_method, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :instance_variable_get, :instance_variables, :method, :public_method, :singleton_method, :define_singleton_method, :public_send, :extend, :to_enum, :enum_for, :pp, :=~, :!~, :eql?, :respond_to?, :object_id, :send, :display, :nil?, :hash, :class, :singleton_class, :clone, :dup, :itself, :yield_self, :taint, :tainted?, :untrust, :untaint, :trust, :untrusted?, :methods, :frozen?, :protected_methods, :singleton_methods, :public_methods, :private_methods, :!, :equal?, :instance_eval, :instance_exec, :!=, :__send__, :__id__]
by hinkley | 2025-10-18 20:43:43+00:00
I haven't used it much. I know a few people who have.

But as I said above, I realized long ago that languages without IDEs by and large falter in the long term (that's why I'm currently concerned about Jetbrains needing a buggy plugin to do Elixir), so Jetbrains being behind it added a lot of gravitas.

And after fighting with Larry Ellison for a bit, Android phones moved to Kotlin to get around the lawyers.
by BearOso | 2025-10-18 20:44:54+00:00
Video rendering can still be done with overlays, but it's a little more substantial, involving separate planes with the locations configurable on the graphics card. Look up MPO, Multi-Plane Overlay.

Your green stripe is likely because of the classic combination of unclamped bilinear filtering and a texture that's larger than the output region being used as the drawing surface for the video.
by godelski | 2025-10-18 20:46:26+00:00
I think one of the best things to learn from Schmidhuber is that progress involves a lot of players and over a lot of time. Attribution is actually a difficult game and usually we are only assigning credit to those at the end of some milestone. It's like giving a gold medal to the runner in the last leg of a relay race or focusing only on the lead singer of a band. It's never one person that does it alone. Shoulders of giants, but those giants are just a couple of dudes in a really big trenchcoat.

Another important lesson is that often good ideas get passed over because of hype or politics. We often like to pretend that science is all about the merit and what is correct. Unfortunately this isn't true. It is that way in the long run, but in the short run there's a lot of politics and humans still get in their own way. This is a solvable problem, but we need to acknowledge it and create systematic changes. Unfortunately a lot of that is coupled to the aforementioned one.

> I do respect the extent to which he continues his credit-attribution crusade even to his own reputational detriment.

As should we all. Clearly he was upset that others got credit for his contributions. But what I do appreciate is that he has recognized that it is a problem bigger than him, and is trying to combat the problem at large and not just his own little battlefield. That's respectable.
by mleonhard | 2025-10-18 20:47:07+00:00
When I used AWS startup credits in 2019, the AWS console made it very difficult to estimate the bill after the credits ran out. I lost a lot of trust in AWS. Also, there were buried mines in the APIs, like the risk of bad logging running up a $70,000/day bill with CloudWatch Logs.

If I could go back and do it again, I would rent a single machine and deploy with ssh (git pull & docker-compose up) and backup to my laptop.
by pegasus | 2025-10-18 20:47:20+00:00
Provided that the author of the message you're replying to is indeed a member of the Animalia kingdom, they are all those creatures together (at the minimum), so yes, they have seen real light directly.

Of course, computers can be fitted with optical sensors, but our cognitive equipment has been carved over millions of years by these kind of interactions, so our familiarity with the phenomenon of light goes way deeper than that, shaping the very structure of our thought. Large language models can only mimic that, but they will only ever have a second-hand understanding of these things.

This is a different issue than the question of whether AI's are conscious or not.
by osigurdson | 2025-10-18 20:47:45+00:00
>> [1] what is a node? Typically it is a synonym for "server". In some configurations HPC schedulers allow node sharing

I'm sure they mean actual servers / not just cores. Even in traditional HPC it isn't abstracted to the level of individual cores usually since most HPC jobs care about memory bandwidth - even with Infiniband or other techniques throughput / latency is much worse than on a single machine. Of course, multiple machines are connected (usually using MPI / Infiniband) but important to try to minimize communication between nodes where possible.

For AI workloads, they are running GPUs - so 10K+ cores on a single device so even less likely to be talking about cores here.
by daxfohl | 2025-10-18 20:48:11+00:00
This is nothing new. v1 of something is always easy. Now in the coding assistant world, everything is v1. Let the tools go through a few deprecation cycles, weird things being added that don't map to the original intent, floods of overlapping tools and docs and everything else that someone has to reconcile, different LLM technologies that you need to support and adapt to, etc., and then see how things look.

I think all three things you mention come into play, but it's a bit early to judge whether the world has shifted or whether this is mainly a result of everything being fresh and new.
by jmmv | 2025-10-18 20:48:57+00:00
> Ok, this post is mostly about text-based IDEs, but I think the point mostly stands as well for IDEs in general. I'm thinking about Visual Basic or Delphi.

Exactly. I recently recorded a video of me creating a toy app with VB3 on Windows 3.11 and the corresponding tweet went “viral” for similar reasons as this article.

It’s not really about the TUI: it’s about the integrated experience as you say!
by chao- | 2025-10-18 20:50:37+00:00
>Ruby has a concept of mixins (Golang interfaces), these are not objects.

Ruby "mixins" are the affordance of sharing instance methods from a module via a keyword. Modules are objects, and are instances of class Module:

module ProvidesFooMixin def foo = "foo" end class Bar include ProvidesFooMixin end Bar.new.foo # => "foo" puts(ProvidesFooMixin.class) # => Module ProvidesFooMixin.object_id # => (some integer value)

>Neither is `puts`

Like all methods, `puts` is an object:

method(:puts) # => #<Method: Object(Kernel)#puts(*)> method(:puts).class # => Method method(:puts).object_id # => (some integer value)

Here you see evidence of where `puts` comes from: Kernel#puts via Object, which I will now explain in detail.

>What object does the method `puts` belong to?

It belongs to the object you are calling it from within. You don't need to call `puts` with a receiver because it is an instance method, just like you don't need to call an instance method `foo` via `self.foo`. But you could choose to use a receiver, since the `puts` you know and love is just another instance method. You can try `self.puts` for yourself in some context!

Your classes (and their instances) inherit this `self.puts` instance method from the Object class, which includes the Kernel module, which provides `Kernel#puts`. So the only reason you can send it as a message without a receiver is because it is just another instance method (again, the same as calling instance method `#foo` without using `self.foo`).

Caveat: You can build an "alternate universe" object hierarchy by inheriting from BasicObject, and in your alternate universe, you can choose to not `include Kernel`, and you will see that instances of your new objects do not have access to `puts` in their instance scope.
by echelon | 2025-10-18 20:51:30+00:00
It'd be cool if you had to pay a certain amount of money to publish any message.

And then if you could verify you'd paid it in a completely P2P decentralized fashion.

I'm not a crypto fan, but I'd appreciate a message graph where high signal messages "burned" or "donated money" to be flagged for attention.

I'd also like it if my attention were paid for by those wishing to have it, but that's a separate problem.
by franciseni722 | 2025-10-18 20:52:53+00:00
Defect detectives - The giga yield case files. My PTG spots 99.9% of giga flaws - Solve a case, win $25k or a live NFT dashboard pass. Each week, a "crime scene" dataset is dropped from a simulated Tesla Giga factory line, Data is 95% sparse, mimicking real-world sensor noise and incomplete logs. Players must detect "defects" ( e.g., micro-anode cracks,electrode delamination, thermal hotspot anomalies) Gameplay loop is simple 1. Players join via X threads or 'n "case assigned. 2. Download Giga dataset fragment ( Structural CSV/API feed) 3. Runs analysis with PTG ( Probablistic Tesla Graph) or custom script 4. Submit predicted flaw coordinates.
by afro88 | 2025-10-18 20:53:08+00:00
All the things you listed are irrelevant for a touring musician. All they care about is that equipment is used that sounds good. If it's a pain to set up or manage, that's the roadie and live mix engineer's job. Not saying some behringer gear doesn't sound good, just that bands can be very specific about their sound and a blanket "no behringer" rules out a lot of cheaper bad sounding gear in 2 words.

There's also the idealogical standpoint. That Behringher rips off other designs and mass produces them cheaper off shore. I'm in 2 minds about that. I now have a 2600, which would have been impossibly expensive (even with a TTSH) for me.
by ealexhudson | 2025-10-18 20:53:49+00:00
I suspect there is a bit of knee-jerk because so often this pattern is misapplied. I actually quite like the example in the article although I'm basically allergic to CQRS in general.

I think your point about write-ahead logging etc is a good one. If you need a decent transactional system, you're probably using a system with some kind of WAL. If you're event sourcing and putting events into something which already implements a WAL, you need to give your head a wobble - why is the same thing being implemented twice? There can be great reasons, but I've seen (a few times) people using a perfectly fine transactional DB of some kind to implement an event store, effectively throwing away all the guarantees of the system underneath.
by Waterluvian | 2025-10-18 20:54:29+00:00
What I say is that the types exist in your code whether you write them down or not.

When you don’t write them down, you’re saying, “trust me, this works.” But now the types are written down in your head (a very volatile form of memory that can’t be accessed easily by others).

One time when dynamic works well is when “prove this works” is simply not worth the time. Eg. a quick script.
by vacuity | 2025-10-18 20:55:04+00:00
Especially in the case of GP, I'd say Rust is not the main recommendation, although it is one. I would concur that Rust is only one of many decent languages (for memory safety or otherwise).

Still, there are languages with guardrails, and then there are languages with guardrails, and the order for memory safety is probably something like C < C++ < Zig < Rust < managed (GC) languages.
by jauntywundrkind | 2025-10-18 20:55:11+00:00
The API server is the thing. It so happens that the API server can mostly be a thin shell over etcd. But etcd itself while so common is not sacrosanct.

https://github.com/k3s-io/kine is a reasonably adequate substitute for etcd. sqlite, MySQL, PostgreSQL can also be substituted in. Etcd is from the ground up built to be more scale-out reliable, and that rocks to have baked in. But given how easy it is to substitute etcd out, I feel like we are at least a little off if we're trying to say "etcd is also the entire point of k8s" (the APIserver is)
by didibus | 2025-10-18 20:55:20+00:00
The MCP can expose a list of tools, but also a list of prompt templates, a list of resources, it can ask the client to run something through the LLM (called sampling), and it can provide rules for when to follow up with questions.

But you can do all that yourself if you're building your own agent and directly calling a model. But if you want to be able to provide behavior to any agent, that's where MCP comes in.