While I don't know much about Church numbers or the theory how lambda calculus works, taking a glance at the definitions on wikipedia they seem to be the math idea of how numbers works (at the meta level)

I forgot the name of this, but they seem the equivalent of successors in math In the low level math theory you represent numbers as sequences of successors from 0 (or 1 I forgot)

Basically you have one then sucessor of one which is two, sucessor of two and so on So a number n is n successor operations from one

To me it seems Church numbers replace this sucessor operation with a function but it's the same idea

Church ends up defining zero as the identity function, and N as "apply a function to a zero-unit N times"

While defining numbers in terms of their successors is decently doable, this logical jump (that works super well all things considered!) to making numbers take _both_ the successor _and_ the zero just feels like a great idea, and it's a shame to me that the papers I read from Church didn't intuit how to get there.

After the fact, with all the CS reflexes we have, it might be ... easier to reach this definition if you start off "knowing" you could implement everything using just functions and with some idea of not having access to a zero, but even then I think most people would expect these objects to be some sort of structure rather than a process.

There is, of course, the other possibility which is just that I, personally, lack imagination and am not as smart as Alonzo Church. That's why I want to know the thought process!

> Church ends up defining zero as the identity function

Zero is not the identity function. Zero takes a function and calls it zero times on a second function. The end result of this is that it returns the identity function. In Haskell it would be `const id` instead of `id`.

    zero := λf.λx.x
    one  := λf.λx.fx
    two  := λf.λx.ffx

    id   := λx.x

I suspect that this minor misconception may lead you to an answer to your original question!

Why isn't the identity function zero? Given that everything in lambda calculus is a function, and the identity function is the simplest function possible, it would make sense to at least try!

If you try, I suspect you'll quickly find that it starts to break down, particularly when you start trying to treat your numerals as functions (which is, after all, their intended purpose).

Church numerals are a minimal encoding. They are as simple as it possibly gets. This may not speak to Church's exact thought process, but I think it does highlight that there exists a clear process that anyone might follow in order to get Church's results. In other words, I suspect that his discover was largely mechanical, rather than a moment of particularly deep insight. (And I don't think this detracts from Church's brilliance at all!)

You are right to be skeptical.

There are plenty of so called windows(or other) web 'os' clones.

There were a couple of these posted on HN actually this very year.

Here is one example I google dthat was also on HN : https://news.ycombinator.com/item?id=44088777

This is not an OS as in emulating a kernel in javascript or wasm, this is making a web app that looks like the desktop of an OS.

I have seen plenty such projects, some mimick windows UI entirely, you xan find them via google.

So this was definitely in the training data, and is not as impressive as the blog post or the twitter thread make it to be.

The scary thing is the replies in the twitter thread have no critical thinking at all and are impressed beyond belief, they think it coded a whole kernel, os, made an interpeter for it, ported games etc.

I think this is the reason why some people are so impressed by AI, when you can only judge an app visually or only how you intetcat with it and don't have the depth of knowledge to understand, for such people it works all the way.land AI seems magical beyond comprehension.

But all this is only superficial IMHO.

Every time a model is about to be released, there are a bunch of these hype accounts that spin up. I don't know they get paid or they spring up organically to farm engagement. Last time there was such hype for a model was "strawberry" (o1) then gpt-5, and both turned out to be meaningful improvements but nowhere near the hype.

I don't doubt though that new models will be very good at frontend webdev. In fact this is explicitly one of the recent lmarena tasks so all the labs have probably been optimizing for it.

My guess is that there are insiders who know about the models and can’t keep their mouths shut. They like being on the inside and leaking.

I’d also bet my car on there being a ton of AI product/policy/optics astroturfing/shilling going on, here and everywhere else. Social proof is a hell of a marketing tool and I see a lot of comments suspiciously bullish about mediocre things, or suspiciously aggressive towards people that aren’t enthused. I don’t have any direct proof so I could be wrong, but it seems more extreme than a iPhone/Android (though I suspect deliberate marketing forces there, too,) Ford/Chevy brand-based-identity kind of thing, and naive to think this tactic is limited to TikTok and Instagram videos. The crowd here is so targeted, I wouldn’t be surprised if a single-digit percentage of the comments are laying down plausible comment history facade for marketing use. The economics might make it worthwhile for the professional manipulators of the world.

Its always amusing when "an app like windows xp" considered hard or challenging somehow.

Literally the most basic html/css, not sure why it is even included in benchmarks.

While it is obviously much easier than creating a real OS, some people have created desktop managers web apps, with resizeable and movable windows, apps such as terminals, nodepads, file explorer etc.

This is still a challenging task and requires lots of work to get this far.

Those things are LLMs, with text and language at the core of their capabilities. UIs are, notably, not text.

An LLM being able to build up interfaces that look recognizably like an UI from a real OS? That sure suggests a degree of multimodal understanding.

UIs made in the HyperText Markup Language are, in fact, text.

Google does A/B testing for anti ad blockers.

Not only do I get slowdowns and some videos don't load at all at times, but I also get a notification that explains that the reason is using adblockers.

Here I am, totally given up on adblockers, and no way I’m paying for premium, but jesus christ the amount of ads I get, sometimes seems to be one every minute, making most videos unwatchable.

Though it’s mostly good for my addiction since it makes me use youtube less.

Even if we assume this to be true, waymos have the advantage of more sensors and less blind spots.

Unlike humans they can also sense what's behind the car or other spots not directly visible to a human. They can also measure distance very precisely due to lidars (and perhaps radars too?)

A human reacts to the red light when a car breaks, without that it will take you way more time due to stereo vision to realize that a car ahead was getting closer to you.

And I am pretty sure when the car detects certain obstacles fast approaching at certain distances, or if a car ahesd of you stopped suddenly or deer jumped or w/e it breaks directly it doesn't need neural networks processing those are probably low level failsafes that are very fast to compute and definitely faster than what a human could react to

Hello,

The main idea compared to stdweb is to have the ability to call into javascript dynamically but without having to write actual embedded javascript.

From what I've seed stdweb exposes a js! macro with some features to conveniently pass around rust values back and forth.

Also from my understanding of it stdweb also features some abstraction layers of common js APIS based internally on that js! macro.

Ultimately I'd say compared to stdweb, wasm_val aims to provide access to javascript via an API as compared to writing actual embeded js like stdweb does or by writing or generating bindings as wasm-bindgen does.

Edit: Also since wasm_val encapsulates js access in an API it provides additional type-safe guarantees (such as when coercing a JsValue into a rust type)

Also wasm_val does this dynamically, so you could potentially do some stuff during runtime that you couldn't in stdweb due to it using code generation as well.

Hope this answers your question.