1.  

    I was going to make some joke about fully-automated luxury communism or the like but thought we were talking from within the bounds of possibility.

    1.  

      True. The weird rejection of the idea of generics has largely been a community thing, not the core team. I have issues with some element’s of Go’s design (mainly around the lack of sum types necessitating all kinds of silly hackery), but the Go team themselves have always been pragmatic and non-dogmatic.

      1.  

        I see Catala, I upvote.

        1.  

          You can, but the docs all discourage this and at least some of the things in this article won’t work correctly if you do. It’s clearly a build system that’s been designed for in-tree builds and then had support for out-of-tree builds added, rather than one that’s thought about builds with immutable sources from the start.

          1.  

            (a) You couldn’t pay me to drink American ‘beer’.

            (b) I agree completely with your hypothesis, because as we all know, ice cream is tasteless. /s

            1.  

              If the lamda is used in precisely one place, it should be inlined, but you need to make sure that the outer function is specialised for each value. The easiest way of doing this is to make it a template function that takes the opcode as the template argument, then you get a different function. Make sure you don’t use std::function because the type erasure makes inlining harder for the compiler.

              1.  

                Taste buds stop responding when they get cold. If your beer is so bad that you have to deaden your tastebuds to be able to stomach it, then you might consider trying better beer. The US started chilling beer during prohibition for precisely this reason: it was so bad that you couldn’t drink it at room temperature and had to chill it so that you couldn’t taste it as much.

                1.  

                  To me, this just further confirms that you give someone enough data about any 1 aspect and they can likely figure out anything they want.

                  Since phones, watches and soon eyeglasses(?) will have more sensors than Apollo 11, it’s unsurprising that privacy is currently dead, though I hope it gets resurrected soon.

                  1.  

                    Google trends isn’t really a useful metric. What’s more interesting is that there are more and more companies using Clojure commercially. For example, we had Clojure/north conference in Toronto where lots of people presented from companies that are entirely built on Clojure stack. There are lots of new companies popping up doing innovative stuff with Clojure every year. Roam Research being a good example.

                    The communities on Slack, Reddit, and Clojureverse are very active, and constantly growing.

                    There are now projects like Clojurists Together for funding open source ecosystem and ensuring that it’s sustainable. Incidentally, one of the first things that happened from Cognitect being bought by Nubank was that they started funding open source developers on Github.

                    Clojure is a mature language, with a large ecosystem around it, and a very active community. It’s not a hype driven language, but it’s very much sustainable and has been for many years now.

                    1.  

                      ISDN in the UK was crazily expensive (a second phone line was very cheap, which solved the phone-and-use-the-Internet-at-the-same-time problem). With 56K modems, the download speed was only a bit faster (upload was about double), but they were sold as ISDN-2 or ISDN-30 and you paid line rental for each channel (2 or 30) at a rate that was about double that of an analogue phone line. As I recall, you also paid per minute when using the line, so using an ISDN-2 line was more than double the cost of an analogue phone line, using an ISDN-30 line was insanely expensive. It looks as if BT still sells ISDN, though their prices are ‘from …’ and they don’t say what makes them go up. Line rental on a single 64K channel now costs about as much as a 54M line.

                      I remember in the mid ‘90s when a few of my friends started getting 512 Kb/s cable modems: I thought they’d misread the speed - almost ten times as fast as an ISDN line, that couldn’t possibly be real! I didn’t get one until I went to university, where my housemates and I were extravagant and paid extra to get the 1 Mb/s package (split 4 ways). We did all sorts of things like having a shared downloads directory for large things to stop people slowing things down by downloading the same thing as someone else and even had a little proxy for Radio Paradise streams so that everyone could listen without each person using 128 Kb/s of the available bandwidth for a separate stream.

                      I recently upgraded to 900 Mb/s down, 110 Mb/s up FTTP and had to upgrade some of my LAN infrastructure to stop it from being the bottleneck. Living in the future is great!

                      1.  

                        More, the founders / the company behind Clojure were bought up last year by a bank. We all know what this means in other areas.

                        This also happened to Elixir and it seems to be doing fine?

                        1.  

                          I feel this is true for a lot of things. In a sense, modern production languages have just been reimplementing stuff from Lisp for decades now and calling it evolution. Especially the production languages I mention (stuff like Go, Python, C++, Rust, etc.) aren’t really innovating anymore, just taking stuff from functional languages like Haskell, Ocaml and Lisp and making it work with their imperative style.

                          1.  

                            I now want to make a programming language where the fundamental collection is the span (ie, a pointer and length). I think I’ll call it Span-ish.

                            1.  

                              This is something I am unsure about. I too often here advice about Rc RefCelling your way out of borrowchecker fights. I think this is a bad advice, but this is just my own reasoning, rather than empirical observation on many different people learning Rust. To me, interior mutability is one of the hardest aspects of the language, and, while it sometimes can be used to mimic some GC language patterns, it brings a lot of accidental complexity. It’s much harder than doing the Rust thing with owned values and references.

                              To me, this advice seems a bit like “you can embed imperative language in Haskell via state monad, so, to learn haskell, just use state monad”.

                              My own take on learning Rust is that one really needs to sit down and learn the inner logic of the language. Not sure what’s the best way to do this though, I’d say:

                              1.  

                                I’ve been thinking a bit about trying to make a language that takes the best bits of Ada SPARK (nice integration with Why3 for great SMT reasoning, ability to “turn-off” language features, nice bare-metal ergonomics etc…), building off of the work around stacked borrows applied to Rust, and generally trying to lean more into linear + temporal + separation logic. Ada and Rust have shown that some amazing things are possible. This effort might “collapse” into tooling around Rust that tries to prove contracts specified in comments + additional clippy lints that disable more features as well as those in dependencies.

                                  1.  

                                    “Identity creation for resource providers is made costly with a computational proof-of-work mechanism based on the partial preimage discovery first employed by Hashcash.”

                                    Dude, stop. Stop using PoW.

                                    1.  

                                      I think the issues you mention about rust are things that with experience you’ll struggle a lot less with over time. Compile times are a cultural issue in the ecosystem, but you can write code that compiles without spending minutes and minutes waiting on deps. “Experts write baby code” and when you learn which features of rust you don’t need at all, the whole language feels a lot nicer - until you have to read or use other people’s rust lol…

                                      1.  

                                        Perhaps it’s a tongue-in-cheek way of reminding us all that the proof always has a boundary. Is the proof checker and logic sound? Does the theorem state what we think it does? Has the hardware synthesis toolkit been proven correct, or its output been checked? Does the proof model electromagnetic interference (think Rowhammer)? Does it model timing sidechannels (think Spectre/Meltdown)? Do you trust your chip foundry (supply chain attacks)?

                                        Not trying to detract from the value of formal methods, but it’s important to keep the limitations in mind.

                                        1.  

                                          The last time I heard of CMIP was back in 1995 when I was sitting for an undergraduate exam on networks.