Michael Pollan - Deep Agriculture
A Long Now talk by Michael Pollan on the past and future of agriculture.
A Long Now talk by Michael Pollan on the past and future of agriculture.
Andy Weir and Peter Schwartz talking about The Martian and real-life missions to Mars.
A Long Now seminar by Sam Harris, after the release of The End of Faith in 02005.
remoteStorage is an open standard to enable unhosted web apps where users are in full control of their data and where it is stored, while app developers are freed of the burden of hosting, maintaining and protecting a central database.
A prolific collection of D3.js examples (in a nifty viewer that proxies GitHub Gists)
Discussing serverless computing with Ryan Scott Brown.
Be careful what you buy on ebay! Part 2
via mentalfloss
Hard to decide what's neater here, the exploit or the truly kooky sound format.
via jwz
next_release/
./release.sh
to move next_release/
to released/
and released/
to prev_release/
./release.sh --rollback
to revert to prev_release/
Time-delay safety feature — ./release.sh
will no-op until next_release/
is an hour old.
Can then run this from a cron
job and there's a window to catch issues before they are publicly visible.
This will also effectively batch RSS/JSON feed updates to be kind to readers.
Interesting overview on the history and future of the electricity grid (and Texas has it's own grid!)
"fully automated luxury communism" - nice if you can get it!
I'm bailing on the original blog architecture for now.
Using AWS Lambda is just more complicated than it should be and I'd rather just get this thing working.
I reverted a bunch of the complicated changes I had made so far in my static generation script and that was before I'd even figured out how to handle the mako templates or bundle the whole thing for deployment or hook up the API gateway...
Using Zappa seemed like a possible solution, but even that seems like overkill.
So the new process is:
Another interesting Wait But Why deep-dive into Elon Musk's ventures - this time it's Neuralink.
There seems to be plenty of information on how to use Nginx to proxy content stored in an AWS S3 bucket , but it took me a long time to figure out how to also get url rewriting to work in conjunction with this.
I wanted to rewrite the $uri
to allow links to omit
index.html
from directories and also to omit .html
extensions,
and came up with the following (this goes in the server
block, before the location
block below):
rewrite ^/somepath/(.+)\.(html|json|rss|css)$ /somepath/$1.$2 last;
rewrite ^/somepath(|/.+)/$ /somepath$1/index.html last;
rewrite ^/somepath/(.+)$ /somepath/$1.html last;
This works as follows:
$uri
has a known extension, rewrite as itself and break out
of the rewrite block.
index.html
to directories and break out of the rewrite block.
.html
extension.
Note that the list of extensions in line 1 needs to include everything you serve from
S3, otherwise a .html
extension will be added and it will 404.
Once that's done, you can then pass any requests to /somepath/
through to S3 (I have the bucket permissions set to public-read
, you may need to use a different proxy_pass
url):
location /somepath/ {
proxy_intercept_errors on;
proxy_hide_header x-amz-id-2;
proxy_hide_header x-amz-request-id;
proxy_pass https://s3.<region>.amazonaws.com/<bucket>/;
}
When debugging, it may help to enable logging of rewites:
rewrite_log on;
error_log /var/log/nginx/<somepath>.error.log notice;
Advice for parents dealing with kids and social media
Easily add user-friendly command-line arguments.
Lightweight CSS grid and typography
JSON version of RSS/Atom
Lightweight Python template engine
After implementing my bot in Python, I thought I'd try porting it to other languages as an opportunity to learn a bit of Go and Rust.
Both Go and Rust are statically typed and compile to a single self-contained binary, which is appealing as there is no need to maintain a virtualenv and install dependencies on the server.
The parsing code for "rain" messages is a good starting point to compare the bots. Each is using a "parser combinator" library to parse the messages.
Quick thoughts: Python & Go are both pretty sane. There's almost certainly a better way in Rust, but I found it considerably harder.
The tests are stored in different places in each version so the total line count is not comparable, and the Rust version includes "ignore case" code that is built into Python's parser combinators, and that I added into a fork of the Go parser library.