Yeah, this is a difference I noticed almost as soon as I appeared here! Where I come from, this [the idea that the best programmers are in their 20s] is completely ridiculous. The most important thing in software design is problem framing and you need a lot of expertise for that. The best software designers in our world are often in their 50s or 60s!

    I enjoyed this article and I can’t help but feel it was written just to make the above point.


      In addition to reducing the load on the root servers, QNAME minimization improves privacy at each stage of a request.

      quoting isc.org:

      “Let’s say you want to visit a blog site at https://someblogname.bloghosting.com.pl. In order to determine which IP address to connect to to reach that link, your computer sends a request to your ISP’s resolver, asking for the full name - someblogname.bloghosting.com.pl, in this case. Your ISP (or whoever is running the network you are using) will ask the DNS root, and then the top-level domain (.pl in this case), and then the secondary domain (.com.pl), for the full domain name. In fact, all you are finding out from the root is “where is .pl?” and all you are asking .pl is “where is .com.pl?” Neither of these requests needs to include the full name of the website you are looking for to answer the query, but both receive this information. This is how the DNS has always worked, but there is no practical reason for this today.”

      For BIND, it’s qname-minimization ( strict | relaxed | disabled | off ); for unbound, it’s qname-minimisation: yes.

      About 51% of DNS resolvers do QNAME minimization now: https://dnsthought.nlnetlabs.nl/#qnamemin


        I do not personally consider the AGPL to be a Free Software license

        Any further discussion is moot, and anything you’ve said has been pedantry at best and pointless at worst.

        I am reminded of the discussions in the 90s as to why the GPLv2 was not free software and why the only real free software license was the MIT license for exactly the same reasons you state here.

        Those discussions were pointless then, and this is pointless now.


          Well, that’s legitimate loophole abuse, not a scam.

          What was the reason you could not use USSD requests for balance checking?


            There was originally a debate about whether the version number after 3.9 should increment to 4.0 or to 3.10. The decision now has been made in favor of calling it 3.10.

            As far as backwards-incompatible changes are concerned, there is no requirement that the major version be incremented for that; Python did backwards-incompatible changes all through the 2.x series, and has done them in the 3.x series as well. There is a process for it which stretches out over a multi-year span to give people time to prepare.


              l and I

              Perhaps I’m missing something, but if I type them in the code sample input box on Compute Cuter (selecting Fantasque Sans Mono) they look different to me?


                Happy to help! I hope it works well for you :)


                  The AGPL does not protect you against the original author, or against the original author prioritizing their business model over your needs.

                  All of these recent relicensings have in common that the original author(s) (really, their VC backers) are prioritizing their business model over your needs.


                    A reminder that GNU is not open source but free software

                    A reminder that the very first sentence of my comment began by pointing out:

                    freedom from competition is not one of the core freedoms of any FSF/GNU manifesto.


                    The amount of revisionism from people who want to make money off the backs of software others made would be disappointing if not completely expected.

                    A reminder that the essentially ideal software business, as advocated by the Free Software Foundation, Richard Stallman, and the Free Software movement, consists of selling the effort of software, which includes not just new greenfield development projects, but also maintenance and improvement of existing software which, yes, often will have been written by others (since in the ideal Free Software world, a recipient of software always has the freedom to perform or contract out such maintenance and improvement).

                    And a reminder that this wave of recent relicensings is entirely about ensuring that the VC-backed SaaS startup of the original authors of (insert project name) get to monetize the work of everyone who contributed under the prior more-Free license, while nobody else does.

                    In todays world the AGPL is the minimal license that any software which pretends to care about users freedom should be.

                    A further reminder that if you check my history, I do not personally consider the AGPL to be a Free Software license, and point out at every opportunity that it only is considered one by the FSF due to a combination of fiat (rather than adherence to principle) and an explicit AGPL-specific exception clause added to the GPLv3. The plain GPL does not allow passing on less freedom to downstream recipients than you yourself received from upstream. The AGPL requires that you pass on less freedom in certain circumstances. The moment that principle of conservation of freedom is compromised, the entirety of the Free Software moral position is not merely compromised, but utterly collapses beyond repair.


                      OK, I retract my comment, the examples here https://cormullion.github.io/pages/2020-07-26-JuliaMono/#examples were just placeholders as the webfont hadn’t loaded in. That’s fine, the “serif fonts” were kinda meh ;)


                        Honestly when is that ever a real issue? You’ve got syntax highlighting, spellcheck, reference check, even a bad typer wouldn’t accidentally press the wrong key, you know to use mostly meaningful variable names and you’ve never used L as an index variable… So maybe if you’re copying base64 data manually but why?


                          It does? Where are they?

                          And yeah, obviously any particular font won’t be for everyone, but that’s all right and I like JuliaMono :)


                            I was looking exactly for a font like Julia for working with Isabelle/HOL, since it also heavily relies on Unicode. Thanks for this tip!


                              Exactly. I’m all for AGPL and have no problem with this license. But the CLA gives them propriety of the entire code base, so I’m asking: what prevents them from pulling an ElasticSearch move and say “we’re going ‘source available’ now, it’s kinda like FLOSS, but not really”

                              If the code was own by multiple people and covered by AGPL, this would prevent such a move.


                                I was going to reflexively complain that JuliaMono is sans-serif only , but I now see it has serif versions too, which is frankly a bit weird, but not unwelcome.

                                It’s sans-serif straight through, see below…


                                  I don’t really have a say into what the Rust community decides, but I’m predicting that “yeet” as a term will age spectacularly badly. It would be like naming a keyword “groovy” in the 1970s and still have to live with it today.


                                    I really like using a font called “JuliaMono” because it has nicely designed mathematical symbols and brackets. It makes programming with unicode (which I think is cute) a lot more enjoyable for me.

                                    e.g. a function to test if its input is a pangram can look like this:

                                    ispangram(str) = lowercase(str) ⊆ 'a':'z'

                                    Which is both a beautifully simple way of describing what a pangram is and (in my opinion) a cute way to write it. Using a font where the subset symbol fits nicely with the monospace font makes it look more natural and makes me more likely to do it.


                                      We’re on 3.7 successfully with fastapi though, and have been for some while. I’m sure 3.9 will be supported long enough for python 3.10+ and fastapi to sync up properly.


                                        C++ standards move much faster and tend to break compatibility more, the ABI guarantees are much less useful, compilation times are much worse, etc. Some people just prefer a simpler, more stable language.


                                          I sort of feel like this is on the user? If the user doesn’t want all their browsing data to be leaked to Google and used for targeted ads, they should just not use Chrome, right?

                                          I mean, I get that it’s more complicated than that. But I feel like the right approach is to try to inform users, rather than try to protect users from their own browser.