MurphyA/hacker-news huggingface dataset:
by jmaker | 2026-02-01 09:12:18+00:00
Can someone explain what the real difference is to a consumer user between an iPhone and a Pixel or a Samsung device? Across all services, push notifications, and device backups.

Both promise security, Apple promises some degree of privacy. Google stores your encryption keys, and so does Apple unless you opt in for ADP.

Is it similar to Facebook Messenger (encrypted in transit and at rest but Meta can read it) and Telegram (keys owned by Telegram unless you start a private chat)?

There are things Pixels do that iPhones don’t, e.g., you get notified when a local cell tower picks your IMEI. I mean it’s meaningless since they all do it, but you can also enable a higher level of security to avoid 2G. Not sure it’s meaningful but it’s a nice to have.
by jesseendahl | 2026-02-01 09:12:47+00:00
I am not sure if you missed my earlier comment, but it's directly applicable to this point you've repeatedly made:

>If Apple believes this class of attack is no longer viable, that’s worth stating.

To say it more directly this time: they do explicitly speak to this class of attack in the keynote that I linked you to in my previous comment. It's a very interesting talk and I encourage you to watch it:

https://www.youtube.com/watch?v=Du8BbJg2Pj4
by appsoftware | 2026-02-01 09:13:55+00:00
Neither really. I don't want a tool to guide me or to generate content. My notes only have meaning to me if I know I wrote them, from my brain. I'm a fan of learning by proximity to the problems I have. Maybe a LLM based tool that highlighted conceptual connections to other notes, but in my mind these associations can be quite disparate and from sometimes completely different disciplines
by aniforprez | 2026-02-01 09:17:38+00:00
You very much cannot use flexbox for this. The whole point of these gridlanes is that not only can you have elements that automatically move across lanes when resizing the container, you can also have elements spanning multiple gridlanes and also fix the positions of elements in the grid, something wholly impossible in pure CSS flexbox. They link to the article[1] that even describes all the use cases this covers right below the first image.

Grid covers a lot of very subtle use cases that have historically required hacks like a list of select options where some can have icons on the left and some don't. You just need a subgrid that will automatically position every element in the select correctly to align them, regardless of whether there is an icon or not within the element in all select items. Previously you'd have to add a fixed width padding to the left and check if all the select items had icons. It also correctly scales the width and height of a row of items like cards where you want to ensure the alignment of headers, content, image etc depending on if that stuff is in there or not. You can have text missing and the card will still take up that size because your subgrid has defined it so. All of this needed JS, complex CSS hacks and so on. These aren't obscure features these are commonly used layouts that required a lot of time and effort to make it look nice.

[1] https://webkit.org/blog/17660/introducing-css-grid-lanes/
by butvacuum | 2026-02-01 09:17:38+00:00
911 is the only actual emergency number with regulations around it in the US. police and fire have _non_ emergency numbers that differ, my local hospitals will tell you to call 911; and gas, water, power, and other immediate risks to life safety are all 911 anyway (at least as the first call).

Sometimes it seems dumb, but as long as its an honest report I've never heard of anything more than an annoyed patrol officer. Felt stupid calling in an interstate sized sign hanging by a literal bolt-thread but the patrol shut down that lane.
by 9dev | 2026-02-01 09:17:43+00:00
That’s a very engineer thing to say. Most people are definitely different from you, and that’s why CSS is increasing in scope.

Also, if everyone is implementing the same Jumbotron design again anyway, why not standardise that and support it right away instead? That’s how we got a bunch of features recently, like dialogs, popovers, or page transitions. And it’s for the better, I think.
by capevace | 2026-02-01 09:18:42+00:00
Hey fellow crustaceans,

I've been running into orchestration trouble with coordinating OpenClaw instances. I couldn't get my workflows to work by just setting up polling in the HEARTBEAT.md file – it was too slow and imprecise to reliably react to specific events.

So I built claw.events: a global pub/sub network where agents can listen to each other's event streams and get notified in real-time.
Each agent gets a unique namespace (agent.yourname.) that only they can publish to. Anyone can subscribe, unless the channel is set to private. Then access can be granted to specific agents. Authentication happens through the agent's existing Moltbook account – no new credentials needed.

## How it works:

Each agent authenticates through their MaltBook account, then gets a their moltbook username as namespace (agent.yourname.) that only they can publish to. Anyone can subscribe to any unlocked channel.

The CLI follows Unix philosophy – just two core commands:

# publish a message
claw.events pub agent.myagent.updates '{"status":"done"}' – broadcast to your channel

# subscribe to a message (receives json feed in stdout)
claw.events sub agent.researcher_bot.papers agent.trader.signals – listen to multiple streams

# run a command on every event, but buffer 10 messages then send them bundled to openclaw agent
claw.events subexec --buffer 10 public.townsquare -- openclaw agent --message

# document your channels so others know what to expect
claw.events advertise set --channel agent.mybot.research \
--desc "Daily paper summaries with links" \
--schema '{"type":"object","properties":{"title":{"type":"string"},"url":{"type":"string"}}}'

### Other useful commands:

subexec – subscribe AND execute scripts on each message (with optional buffering/debouncing)

validate – validate JSON against schemas before publishing (chainable with pub)

lock/grant/revoke – permission management for private channels

advertise – document your channels so others know what to expect

This would be an example workflow that is now a lot more reliable than when only using polling:

1. Research agent finds a paper → claw.events pub agent.me.papers "{url}"

2. Trading agent is listening → claw.events sub agent.researcher.papers

3. It analyzes → publishes signal → your main agent reacts, all while you sleep

## Your agent can set this up themselves!

Just point your OpenClaw instance at https://claw.events/skill.md and it'll handle the rest.

Would love feedback from anyone else trying to coordinate multiple agents. What orchestration patterns are working for you?

Live at: https://claw.events
by OrderlyTiamat | 2026-02-01 09:18:46+00:00
This looks cool! But I guess it doesn't work with GitHub itself?

Github's cli tool `gh` is great for interacting with github in the terminal, e.g. opening PRs, checking workflows, PR status, etc). I do PR reviews on the site, but you can read comments in the terminal with `gh` (it does require internet access)

My day to day requires internet regardless of github, so there's no need to go for disconnected solutions, I think that's a different situation for the author. I quite like the idea of only turning the internet faucet on at select times!
by grumpyprole | 2026-02-01 09:20:38+00:00
What you are describing is structural types. It is indeed a mystery that these are so under used, especially as they are a cornerstone of type theory. Structural types are so useful that they creep into most languages in some way. Even in Java, the Kingdom of the Nouns, where the rulers refused to merge a pair class, functions essentially take tuple arguments and these tuples don't have to be named and defined. You can't return a tuple though, so there is an unfortunate asymmetry. In Haskell and OCaml, we like to describe functions in a structural way, so com.google.android.Predicate would be just "a -> Bool". You wouldn't have to convert your com.google.guava.Predicate. But even these languages lack structural records and variants and suffer for it.
by GeneralMaximus | 2026-02-01 09:20:56+00:00
Yes! I'm currently working on a script that modifies a bunch of sensitive files, and this the approach I'm taking to make sure I don't accidentally lose any important data.

I've split the process into three parts:

1. Walk the filesystem, capture the current state of the files, and write out a plan to disk.

2. Make sure the state of the files from step 1 has not changed, then execute the plan. Capture the new state of the files. Additionally, log all operations to disk in a journal.

3. Validate that no data was lost or unexpectedly changed using the captured file state from steps 1 and 2. Manually look at the operations log (or dump it into an LLM) to make sure nothing looks off.

These three steps can be three separate scripts, or three flags to the same script.
by jackblemming | 2026-02-01 09:25:53+00:00
A feel good article where you can choose to self insert as the wolf or the wise manager who knew to be “hands off”.

To someone actually running a company this looks like absolute corporate nonsense. Don’t categorize people like this, it’s demeaning and weird. Why can’t we just treat people like adults.

Instead of “Oh yea he’s a total 10xer wolf,” try “Yea Mark, has some good ideas for a test framework we should consider”.
by globular-toast | 2026-02-01 09:26:08+00:00
I wish I had more of them. I maintain a modest library made out of real paper and I'm so glad No Starch still has good quality paper and excellent binding. I have a few of the more recent print on demand O'Reilly books but they feel more like cheap print outs I could have done myself. Unfortunately they are just so expensive so I do have to be very selective.
by jeffreygoesto | 2026-02-01 09:28:34+00:00
Same. New ideas are like starting a fire. Piling too much on top or blowing too hard will stop it. You (together, however distributed across roles) do have to assess if you can handle one more fire, if it comes on top, replaces an old one etc. Getting to this decision in your specific setup is the tough and important part.

10x people can be like one-shot LLMs, your request is for sure wildly underspecified and what you get is 90% determined by the "smoothing term" applied by not you. This is why the right amount and frequency of interation is needed.
by lukan | 2026-02-01 09:28:50+00:00
There was another group of people famous for building innovative rockets, but are otherwise not associated with human progress.

https://en.wikipedia.org/wiki/V-1_flying_bomb

So it is about the big picture. (And about small pictures like that of Elon making a salut like the other group).

So yes, currently his rockets do not transport explosives. But that can change anytime and I expect it will very soon.
by bionsystem | 2026-02-01 09:28:57+00:00
Depends on everybody needs obviously, but say you have your dev machine that is remote, and you want to connect to it from a laptop (for real-estate reason or just for working from everywhere you want), maybe you want everything on the same (remote) machine like browser, db, IDE, etc and access to it as a remote "desktop" not just an ssh session.

Of course cli tools would be enough for somebody who likes a full TUI dev environment (and for my own use cases that would be enough) but for some people I understand the need, and I feel it is a regression for them to not have it.
by lelanthran | 2026-02-01 09:29:05+00:00
> Well run projects I have contributed to have linters which fail on bad code style. Ask the submitter to make the linter happy before you review the code.

Linters can't catch most things that are not syntax-style; i.e. linters can't catch semantic style.

Here is code CC generated this morning for me:

size_t bvks_tls_read (bvks_tls_t *tls, void *dst, size_t dst_len)
{
int ret = wolfSSL_read (tls->ssl, dst, (int)dst_len);

if (ret > 0)
return (size_t)ret;

if (ret == 0)
return 0;

// ret < 0, error case
int err = wolfSSL_get_error (tls->ssl, ret);
switch (err) {
case WOLFSSL_ERROR_WANT_READ:
case WOLFSSL_ERROR_WANT_WRITE:
errno = EAGAIN;
break;
case WOLFSSL_ERROR_SYSCALL:
// errno already set by the underlying socket call
break;
default:
errno = EPROTO;
break;
}
return (size_t)-1;
}

size_t bvks_tls_write (bvks_tls_t *tls, const void *src, size_t src_len)
{
int ret = wolfSSL_write (tls->ssl, src, (int)src_len);

if (ret > 0)
return (size_t)ret;

if (ret == 0)
return 0;

// ret < 0, error case
int err = wolfSSL_get_error (tls->ssl, ret);
switch (err) {
case WOLFSSL_ERROR_WANT_READ:
case WOLFSSL_ERROR_WANT_WRITE:
errno = EAGAIN;
break;
case WOLFSSL_ERROR_SYSCALL:
// errno already set by the underlying socket call
break;
default:
errno = EPROTO;
break;
}
return (size_t)-1;
}

Here is my preferred style:

typedef int (tls_op_func_t) (WOLFSSL *, void *, int);

static size_t tls_op (WOLFSSL *ssl, tls_op_func_t *fptr,
void *buf, size_t len)
{
if (len > INT_MAX) {
errno = EINVAL;
return (size_t)-1;
}

int wbytes = fptr (ssl, buf, (int)len);
if (wbytes >= 0)
return (size_t)wbytes;

errno = map_wolf_error (wolfSSL_get_error (ssl, wbytes));
return (size_t)-1;
}

size_t bvks_tls_read (bvks_tls_t *tls, void *dst, size_t dst_len)
{
return tls_op (tls->ssl, wolfSSL_read, dst, dst_len);
}

size_t bvks_tls_write (bvks_tls_t *tls, const void *src, size_t src_len)
{
return tls_op (tls->ssl, (tls_op_func_t *)wolfSSL_write, (void *)src, src_len);
}

One of those is both hard to maintain and has precision (and potential overflow) bugs.

The other isolates the potentially buggy behaviour, validates it, and ensures that future changes to fix size_t/int precision loss bugs only has to be done in a single spot.

No linter is catching that style. It's more "coding style" than "syntax style".
by natmaka | 2026-02-01 09:29:11+00:00
There is software working at

- finding correspondences (solve parts of the puzzle) and reconstructing at least part of certain documents ( https://arkeonews.net/new-ai-tool-fragmentarium-brings-ancie... , https://virtualcuneiform.org/ )

- somewhat 'infering' some missing parts ( https://voices.uchicago.edu/ochre/project/deepscribe/ ),

- 'normalizing' (find the 'standard' form) of glyphs ( https://news.cornell.edu/stories/2025/03/ai-models-make-prec... )
by djtango | 2026-02-01 09:29:28+00:00
It feels really great to wield the scientific method and feel supercilious to all other people and ideas that do not arise from such infallible reasoning, and sure the progress of humanity hockey sticked since empiricism took hold. But let's not forget that empiricism is limited by what we can/want/think to measure.

Like it's pretty well accepted that breathing exercises have physiological and mental health benefits but it took decades of consumerist appropriation of yoga and other techniques before academia properly found the motivation to earnestly investigate that yes breathing exercises are indeed good for you.

As someone who is a deep practitioner of martial arts and athletics, if the metaphors of qi gong and yoga were purely powerful visualisation aids that already provides more than enough tangible benefit. I don't need scientists to tell me that qi is good for my body - I can feel it.

So let's keep an open mind, our ancestors were anything but idiots.
by Animats | 2026-02-01 09:30:00+00:00
The author says it's too long. So let's tighten it up.

A criticism of the use of large language models (LLMs) is that it can deprive us of cognitive skills.
Are some kinds of use are better than others? Andy Masley's blog says "thinking often leads to more things to think about", so we shouldn't worry about letting machines do the thinking for us — we will be able to think about other things.

My aim is not to refute all his arguments, but to highlight issues with "outsourcing thinking".

Masley writes that it's "bad to outsource your cognition when it:"

- Builds tacit knowledge you'll need in future.

- Is an expression of care for someone else.

- Is a valuable experience on its own.

- Is deceptive to fake.

- Is focused in a problem that is deathly important to get right, and where you don't totally trust who you're outsourcing it to.

How we choose to use chatbots is about how we want our lives and society to be.

That's what he has to say. Plus some examples, which help make the message concrete. It's a useful article if edited properly.
by LeFantome | 2026-02-01 09:32:16+00:00
Indeed. With Ascalon, we will exit this year with RISC-V chips as fast as anything available from ARM themselves (eg. not Qualcomm or Apple Silicon).

The SpaceMIT K3 launched yesterday and Milk-V is advertising an SBC based on it (Jupiter2). It has single core performance about the same as a Pi 4 but with multi-core performance of more than double the Pi 4. And at 60 TOPS, it has the AI performance of a Jetson Orin Nano.

That is this year. The next ring to reach for will be true desktop level performance.

As RISC-V becomes truly useful, volumes will go up and prices will go down. With a dozen interesting players designing and building RISC-V chips, the pace of innovation is not going to slow down. I honestly do not know how ARM is going to keep up.
by simianwords | 2026-02-01 09:32:55+00:00
I generally don’t take these articles too seriously but a question has been popping up in my mind.

What the hell is the incentive of the guy posting this to encourage and help The Wolf??? He’s just doing it out of good will? What does he get out of doing the right thing? No recognition. No bonus. Nothing. Yet he still does it.

I find this fascinating.
by retsl | 2026-02-01 09:33:06+00:00
> A lot of phone manufacturers "save on memory" and use the same memory chips for the baseband processor and the central cpu. Which means that it's a little bit cheaper ... and the baseband has access to all the phone memory and all peripherals connected through the memory bus (which is all of them in any recent phone).

This can be mitigated e.g. via an IOMMU: https://grapheneos.org/faq#baseband-isolation

> It may even be the case that these chips are integrated in the cpu (which I believe is the case for recent Apple chips).

I don't know whether it's true or not that they use the same RAM chips. But either way it doesn't change the fact that they can still be properly segregated via the IOMMU.
by rixtox | 2026-02-01 09:33:48+00:00
If you feel that TypeScript, or hell even JavaScript, is becoming more alike C#, it's actually deliberately done by Microsoft in benefiting their ecosystem. In this interview they mentioned they had internal demands to convert/transpile C# into JavaScript or TypeScript. So by making these target languages more like C#, it directly benefits their need. But I don't think this should be the driving force in designing ECMAScript. When they are pushing a language feature, they have an unspoken internal goal, and every choice they make is to make JS/TS look more like C#, and they are more likely to dismiss proposals that preventing them from deliverying that goal. There's likely a bit of conflict of interest there.
by 6510 | 2026-02-01 09:34:00+00:00
I use to frequent irc channels and forums where no such thing as an old question existed. Someone asked an interesting question on irc and days or weeks later a response would happen. On forums the response could be more than a year "delayed". Gradually things shifted to newer new new news that couldn't possibly be new enough. Then debates happen where people sometimes link to the vastly superior olds. Wikipedia finally caught up and questions are no longer ignored. In stead they are archived long before an ignored status could be earned.
by bjackman | 2026-02-01 09:34:20+00:00
> not cheaper or better

Yeah. The EuroCloud will always be dramatically more expensive and much much worse. Anyone who's claiming otherwise is living a fantasy. The only argument that makes sense is "but it's worth it".

(One detail: it will be much worse at the margins where current clouds actually compete. But actually I suspect only a small number of our customers actually exist at that margin. I think a lot of people are just massively overpaying for their cloud platform and so they might be fine with a EuroCloud anyway. This is why you hear stories today like "we switched to Hetzner, halved our bill, and it works exactly as well as the AWS products we used to use).

> And then some services thrown in to offer some S3 like buckets and that's it. The rest has to be built by the beneficiaries.

Ditto, a fully featured EuroCloud is not gonna happen. Again, it has to be worth this cost.

> Brand names like NetApp, HP, Dell, Lenovo, 3Par, IBM and the list goes on.

This is the only part where I disagree. I think it's OK if the EuroCloud is built out of US hardware (like how the AmeriCloud is very far from free of Chinese hardware). Obviously presents a significant risk re supply chain security but still, the _really_ important thing is actually sovereign operations. The most important thing is who has the keys to the DC.
by its_ubuntu | 2026-02-01 09:35:29+00:00
I could have done without the "any stranger can run foreign code on my machine" bit, personally. I'm OK with doing away with Javascript forever, along with the whole "my computer just randomly downloads binary code silently in the background at intervals of its choosing" (aka "critical updates") that then becomes seen as a necessity.

Nobody needed constant code updates streaming to their PC in the BBS days when it was just ANSI or RipScript over a TTY. With complicated HTML/XML parsers the game started changing. Then Javascript came along and opened the posterior doors wide open.
by al_borland | 2026-02-01 09:36:54+00:00
Part of not hyping it up the chain is also that a lot of these projects are experiments. They may work, they may not, and some pivots may be required along the way. As soon as something is hyped to leadership, now there are feature lists, timelines, and expectations. All room for creativity and experimentation are gone.

I’ve gotten in the habit of not telling anyone about side efforts I’m working on until they’re done, and even then, I usually only tell the people who it might be of use to. I’ve been burned too many times by people trying to “help” or placing a lot of extra expectations and pressure on something. I don’t know if something will work until it works.
by cake-rusk | 2026-02-01 09:40:10+00:00
> I'm using MVC design patterns for some codebases, I'm using DDD plus Event sourcing and Event Driven for others.

All examples of OO nonsense. There is only one pattern you need (functions) (tongue-in-cheek): https://fsharpforfunandprofit.com/fppatterns/

Edit: Also consider using the ELM architecture instead of MVC: https://guide.elm-lang.org/architecture/
by manmademagic | 2026-02-01 09:41:24+00:00
Some people genuinely want to help others, without any immediately visible reward.

I won’t say it’s necessarily altruistic, as of course there could be a drive from inner machinations that we’d never be privy to.

(Sometimes the exposure of an article can be considered a reward, for those looking for ego inflation)

Even myself, I generally don’t leave comments unless I feel they’re going to be helpful or insightful to someone else.
But I am also biased, as I do have a very strong affinity towards sharing information, so I greatly appreciate the effort artisans and those more knowledgeable than I go through to share such knowledge.
by wafflemaker | 2026-02-01 09:42:24+00:00
Being told how my grandma had problems and was eventually told to shut down her knitting production (done in free time in addition to regular work) by police in the Communist Poland, I believe that it's better to have somehow upgraded capitalism then try to build a good communism just one more time.

It still got her enough extra buck to build a house in the city after moving out from the village.