It's cool, but I would never use this for real.

It's very rare to find something that prevents you from directly updating. Nixpkgs tries very hard to no require new Nix features, so it evaluates with even Nix versions from a decade ago. Also, NixOS options and packages are frequently changed, but the automatic migrations (mkChangedOptionModule, mkRenamedOptionModule, alias, etc.) are never removed in practice.

Since the binary cache has never been cleared since its creation (2002?), it should actually be easy to install a super old NixOS release and upgrading it to the latest to see what happens.

By the way, there are LTS versions of NixOS, just not officially supported. See https://docs.ctrl-os.com/.

https://en.wikipedia.org/wiki/Server_Name_Indication#Encrypt...

That's incorrect, a MitM can only reveal the server hostname by inspecting the SNI during the TLS handshake, but the HTTP request, including the URL and headers, is encrypted.

[1]: https://mrshu.github.io/github-statuses/

AFAIK, WiFi has always been doing CSMA/CA and starting with the 802.11ax standard also OFDMA. See https://en.wikipedia.org/wiki/Hidden_node_problem#Background

https://news.ycombinator.com/item?id=14986324 (2017)

https://news.ycombinator.com/item?id=20167686 (2019)

https://news.ycombinator.com/item?id=25568766 (2020)

https://news.ycombinator.com/item?id=37116487 (2023)

> the class of functions [...] is what I would call exponential-logarithmic functions or EL functions; that is, they are the functions that can be expressed using some finite combination of constant functions, the identity function, exp, log, composition, and arithmetic operations (+−×÷). Some authors call this class of functions elementary functions, but that term is now more commonly used in a different sense, which includes algebraic functions.

Evidently my professor was in the exponential-logarithmic camp.

[1]: https://mathoverflow.net/a/442656

> The elementary functions of analysis, that is powers, roots, exponentials, logarithms and their inverses, functions obtained from the former by arithmetic operations or composition, admit the limit f(p) for x → p, for any p in their set of definition. The study of such functions, which is not limited to the sole real functions of real variable, is carried out naturally in the setting of metric spaces.

That said, I'm relatively sure that a definition was given in class and it didn't include arbitrary roots: despite being notoriously difficult, the exam didn't require students to draw the graph of any elementary function including implicitly-defined algebraic roots.

I picked up another one of the old recommended books [2] and it seems to be similarly vague; while the book currently taught in my university [3], gives this definition:

> The following functions (from ℂ to ℂ) are called the elementary functions of the Analysis:

> 1) Rational functions (integral or fractional)

> 2) Algebraic functions (explicit or implicit)

> 3) The exponential function

> 4) The logarithm function

> 5) All those functions that can be obtained by combining a finite number of times the functions of kind 1)...4).

So, roots of arbitrary polynomials implicitly defined are indeed considered elementary. I never knew this.

[1]: https://search.worldcat.org/title/1261811544

[2]: https://search.worldcat.org/title/801297519

[3]: https://search.worldcat.org/title/935666878

> Elementary functions typically include arbitrary polynomial roots, and EML terms cannot express them.

If you take a real analysis class, the elementary functions will be defined exactly as the author of the EML paper does.

I've actually just learnt that some consider roots of arbitrary polynomials being part of the elementary functions before, but I'm a physicist and only ever took some undergraduate mathematics classes. Nonetheless, calling these elementary feels a bit of stretch considering that the word literally means basic stuff, something that a beginner will learn first.

They're primitive in the sense that you can't compute exp(x) or log(x) using a finite combination of other elementary functions for any x. If you allow infinite many operations, then you can easily find infinite sums or products of powers, or more complicated expressions to represent exp and log and other elementary functions.

> Or do we assume that we have an infinite lookup table for all possible inputs?

Essentially yes, you don't necessarily need an "implementation" to talk about a function, or more generally you don't need to explicitly construct an object from simpler pieces: you can just prove it satisfies some properties and that it is has to exist.

For exp(x), you could define the function as the solution to the diffedential equal df/dx = f(x) with initial condition f(0) = 1. Then you would enstablish that the solution exists and it's unique (it follows from the properties of the differential equation), call exp=f and there you have it. You don't necessarily know how to compute for any x, but you can assume exp(x) exists and it's a real number.

It boilds down to using a Linux-specific API, though it's really BSD that is lacking support for a standard (RFC 5014).

For some reason, OpenSSH devs refuse to fix this issue, so I have to patch it myself:

    --- a/sshconnect.c
    +++ b/sshconnect.c
    @@ -26,6 +26,7 @@
     #include 
     #include 
     #include 
    +#include 
     
     #include 
     #include 
    @@ -370,6 +371,11 @@ ssh_create_socket(struct addrinfo *ai)
      if (options.ip_qos_interactive != INT_MAX)
        set_sock_tos(sock, options.ip_qos_interactive);
     
    + if (ai->ai_family == AF_INET6 && options.bind_address == NULL) {
    +  int val = IPV6_PREFER_SRC_PUBLIC;
    +  setsockopt(sock, IPPROTO_IPV6, IPV6_ADDR_PREFERENCES, &val, sizeof(val));
    + }
    +
      /* Bind the socket to an alternative local IP address */
      if (options.bind_address == NULL && options.bind_interface == NULL)
        return sock;