sashametro

If you run those commands without the +short you will see that the TTL values for those responses are less than 59 (which for Google Public DNS, indicates they are cached, and explaining why the IP addresses shown are not yours).

The o-o.myaddr.l.google.com domain is a feature of Google's authoritative name servers (ns[14].google.com) and not of 8.8.8.8. You can send similar queries through 1.1.1.1 (where you will see that there is no EDNS Client Subnet data provided, improving the privacy of your DNS but potentially returning less accurate answers, as Google's authoritative servers do not have your IP subnet, but only the IP address of the CloudFlare resolver forwarding your query.

However, 9.9.9.10 does not perform DNSSEC validation, as 8.8.8.8 (Google), 64.6.64.6 (Verisign), 9.9.9.9 (Quad9), and now 1.1.1.1 (CloudFlare) do, so results may not be as trustworthy.

And if you use DNS-over-HTTPS to get your answers from Google, Comcast can't modify them.

Note that although it is not documented, when you query the Google DNS-over-HTTPS service from Chrome, it will usually use QUIC. You can check this at chrome://net-internals/#quic, and will probably see something like this (look DNS/HTTPS/QUIC/UDP/IPv6!):

dns.google.com:443 true QUIC_VERSION_34 [2607:f8b0:400d:c03::8a]:443 10544469510527000173 0 None 2 9 0 9 true

An independent implementation of QUIC (are there any outside of browsers?) would probably work much the same, modulo any changes during the ongoing standardization of QUIC.

Google Public DNS (8.8.8.8) verifies DNSSEC by default. So does Verisign Public DNS (64.6.64.6).

Some measurements of DNSSEC validation show that as much as 15% of Internet domain lookups validate DNSSEC: http://stats.labs.apnic.net/dnssec/XA. Approximately half of that is due to Google Public DNS validation (many sites use both Google Public DNS and other resolvers that do not validate, so do not actually validate DNSSEC overall).

It is very true that less than 1% of DNS zones are signed with DNSSEC, so it is true that "secure DNS" doesn't practically exist, but this a serving side issue, not a lack of client validation.

Note that although it is not documented, when you query the Google DNS-over-HTTPS service from Chrome, it will usually use QUIC. You can check this at chrome://net-internals/#quic, and will probably see something like this (look DNS/HTTPS/QUIC/UDP/IPv6!):

dns.google.com:443 true QUIC_VERSION_34 [2607:f8b0:400d:c03::8a]:443 10544469510527000173 0 None 2 9 0 9 true

An independent implementation of QUIC (are there any outside of browsers?) would probably work much the same, modulo any changes during the ongoing standardization of QUIC.

There are several different implementations of proxies for DNS-over-HTTPS:

https://github.com/aarond10/https_dns_proxy (C) https://github.com/pforemski/dingo (Golang) https://github.com/tssva/dnshttps-proxy (Golang) https://github.com/wrouesnel/dns-over-https-proxy (Golang) https://github.com/CodeFalling/dns-proxy-https (Javascript)

I'd heard that somebody was working on DNS-over-HTTPS support for https://github.com/getdnsapi/getdns at the hackathon in Buenos Aires in April just before DNS-OARC / IETF-95, but have seen no evidence of that.

A bit more obscure, but tremendously fun (and very geeky), are George Gamow's Mr. Tompkins books (http://en.wikipedia.org/wiki/Mr_Tompkins) - I discovered the first two in my high school library, but they would be very accessible to any elementary school child.

Also in the geek mode, why not Abbot's Flatland (http://en.wikipedia.org/wiki/Flatland)?

Given that it is "powered by mxGraph," which is a product of jGraph, that would seem to be the company.

I wonder if the providers of this service have thought about crowd-sourcing the caller-id information, like http://mrnumber.com/ whose free tier harvests number->name mapping from users address books...

If you have an e-mail address in .edu you can have free private repos with unlimited users having access to them. Just register your .edu e-mail on the site and the 5 user limit is removed.

I wonder, if somebody took the same optimization approach (cache-line size optimization) to the tree/hash/etc. data-structures and applied them to matrices, would they be inspired to call them Bobby Tables?

http://xkcd.com/327/ in case you don't get the reference.

I use SourceTree too - I tried to use GitHub for Mac, but it requires a 64-bit Mac, which I don't have. Guess they're just too cool for those old systems...it would be nice if they made that clear upfront, so people could save the wasted download. [EDIT - they do point out 64-bit 10.6+ in the header, it's just gray and I didn't notice it.]

Even if SourceTree is a bit more "map the git commands onto buttons" it works well for me when I'm not on my Linux system, and the fact that it handles Hg as well is a nice bonus.

One of the nice things about Markdown and reStructuredText is that there is actually a substantial overlap in their markup formatting - it is not too difficult to write documents in the common subset, e.g. this brief guide that I wrote up documenting the common subset: http://gist.github.com/1855764 (you can see the same file interpreted as Markdown and reStructuredText there).

My biggest complaint with the various lightweight/plaintext markup formats is the sheer variety and incompatibility of their markup syntax. Pandoc goes a long way to being able to convert the more popular ones easily, but it would have been nice if there had not been so much gratuitous re-invention of the wheel. It's kind of sad that the MultiMarkdown table format is incompatible with the tables in reStructuredText.

When I contribute to FOSS software I know that the odds are very good that other people will actually benefit from the work that I do. Having worked for several startups, I know that the code I was paid to write is more likely than not going to end up in the trash can when the company folds, the project is cancelled or (best case so far) the application is re-written from the ground up by another team. My FOSS code, on the other hand, as humble as it may be, is much more likely to be picked up, used and even improved by others. And there is a satisfaction in knowing that I will always be able to use it whenever I want, something that is not the case with code I have written for my employers