Where am I?

    y = ->(f) {
      ->(x) { x.(x) }.(
      ->(x) { f.(->(v) { x.(x).(v) }) } )
    }

JavaScript:

    const Y = f => (x => f(v => x(x)(v)))
                   (x => f(v => x(x)(v)));

    (define (Y f)
     ((lambda (x) (f (lambda (y) ((x x) y))))
       (lambda (x) (f (lambda (y) ((x x) y))))))

    y :: (a -> a) -> a
    y f = f (y f)

    let z f = 
      let fn = ref (fun x -> x) in
      fn := (fun x -> f (!fn x));
      !fn;;

As you might expect for a moderately complicated topic, ChatGPT is hallucinating. That is beautiful because it is not the Y combinator.

That is the Fixed-point combinator. The Y combinator is used to implement recursion when you can't directly reference the function binding.

In the haskell solution, y is used recursively on the rhs, so it's not the Y combinator, and so it's defining something different and simpler, so of course it looks different and simpler.

Do not trust ChatGPT without first giving it a brief bit of thought yourself.

And also, please don't just post ChatGPT's ramblings here if you have nothing worth adding. Most of us, I think, are here for human discussions, not to talk to chatGPT indirectly. If I wanted chatgpt's ramblings, I would go to that site instead.

  (defun y (f)
    [(op @1 @1)
     (op f (op [@@1 @@1]))])

See here: https://mvanier.livejournal.com/2897.html starting at "Deriving the Y combinator" where it presents a lazy version of Y in Scheme, similar to the Haskell one and argues that it's not valid.

Regarding the Scheme version, there is a shorter form:

  (define (Y f) 
    ((lambda (x) (x x))
     (lambda (x) (f (lambda (y) ((x x) y))))))

Except, the TXR Lisp one doesn't assume that the function takes one argument: the (op [@@1 @@1]) syntax describes a function that takes any number of arguments, and passes them to the funtion produced by [@@1 @@1], so it's like this version:

  (define (Y f)
    ((lambda (x) (x x))
      (lambda (x) (f (lambda y (apply (x x) y))))))

You can see the equivalence:

  3> (expand '(op [@@1 @@1]))
  (lambda (. #:arg-rest-0023)
    [sys:apply [@@1 @@1]
      #:arg-rest-0023])

The double @@ in @@1 means "do not refer to @1, the implicit parameter 1 of this op function: refer to parameter @1 of the next enclosing op function":

  (op f (op [@@1 @@1])
    ^        --- ---
     `-------'---'

These defaults all work together to make a short Y combinator which lets the recursive function have multiple arguments.

  1> (expand '(op f @1))
  (lambda (#:arg-1-0016 . #:arg-rest-0015)
    [f #:arg-1-0016])
  2> (expand '(op f @1 @2 @3))
  (lambda (#:arg-1-0019
           #:arg-2-0020
           #:arg-3-0021 . #:arg-rest-0018)
    [f #:arg-1-0019
      #:arg-2-0020
      #:arg-3-0021])
  3> (expand '(op f @1 @2 @3 @rest))
  (lambda (#:arg-1-0024
           #:arg-2-0025
           #:arg-3-0026 . #:arg-rest-0023)
    [f #:arg-1-0024
      #:arg-2-0025
      #:arg-3-0026
      #:arg-rest-0023])

  fix :: (a -> a) -> a
  fix f = let x = f x in x

That definition is dependent on recursion already being present.

i sometimes think yc is just a front to secure payment for hn servers for many many years.

It actually does a better job than the stock "this comment does not go against our community standards" response you get from the human moderators of any social network.

Not so easy. Jailbreaks are becoming harder to perform every day.

[1] - https://www.youtube.com/watch?v=BrQyMrmRBsk

Yes there are LLMs useful for such things and you could use them to make moderation decisions. YMMV with how "good" you want your moderation to be.

http://www.paulgraham.com/articles.html

This discussion from earlier this year gives some interesting context: https://news.ycombinator.com/item?id=34750727

I've had mine for about a week now, and am using it more than I use my laptop. The "desktop" mode works more than well enough for web browsing and such.

The biggest thing that changed for me was learning that you can use both trackpads on the keyboard at the same time, and use the trigger buttons to "press" a key - or to press shift if you use the opposite trigger from the side your finger is moving.

The same can't be said of the PS; the PS isn't a desktop computer.

Not sure about PS5.

That doesn't mean it's running BSD. For example, MacOS runs a non-BSD kernel with lots of BSD networking code added on-top. It is not a BSD-based Operating System but it does use BSD code to create it's environment. I would not for a single second believe that the PS4 runs an unmodified FreeBSD kernel. There is just no upstream code to support this claim.

That's the whole point. Probably 99% of computer (anything that uses a processor I guess qualifies a computer these days) users in this world don't really care what's running underneath as long it gets the job done. If something can run linux underneath and can still pass as acceptable that's a huge win I think.

SteamDecks are indistinguishable from PCs, since they run more or less exactly the same software as a Linux desktop/laptop would.

Also, the Steam Deck's OS is by far the closest you can get to a traditional Linux distro since it's GNU+Linux under the hood. The built-in desktop mode is extremely close to a basic KDE Arch install, especially after you disable read-only mode. Android doesn't have as full-featured of a desktop experience unless we count Samsung DeX and even then display out is available on a vast minority of devices. iOS has no native display out and iPadOS doesn't even support normal 16:9 screens without black borders. The issue with all of the above devices is that their "desktop" modes are janky afterthoughts while on the Steam Deck it's a core feature.

Also, the deck does not replicate a subset of the desktop experience, it just contains a desktop experience. Unless the KDE desktop is not a desktop now. If that's the case - it runs windows.

But Steam Deck is just running a fork of Arch not some other operating system. From analytics perspective it's indistinguishable to any Linux PC. Also IIRC you can just connect it a display which would turn into a desktop PC.

Is it contrived? They've shown, in their official marketing videos, demonstrations of the steam deck being hooked up to an external monitor and being used to run KDE and Windows 10.

If laptops get to be included (which they usually are), then steamdeck gets to be included.

It doesn't replicate "some subset" of the desktop experience. It does everything a small tower can, plus things it can't do.

You won't use it as a daily driver in handheld mode. The virtual keyboard covers half of the screen, the touchscreen is unusable as a mouse and touchpads are inconvenient.

Ordinary laptops don't have these problems.