it

I find Dawkins's approach to all this incredibly implausible. Think about it. How does a population of creatures split into multiple different reproductively incompatible species via chance mutations? A much more believable mechanism for speciation would be something repeatable like genes being spliced in by a virus, or a new symbiosis like what Lynn Margulis describes in her book Symbiotic Planet. Edit: Nice demo though. And maybe it could be fun to do one based on viruses or symbioses.

What if some subset of the web were set up in such a way that websites could be forked as easily as projects are forked on Github?

Hidden information is entropy. Do you really want more of that in your system?

https://physics.stackexchange.com/questions/29175/why-is-inf...

Also related: The Ubiquitous Matrix of Lies by Charles Eisenstein: https://charleseisenstein.org/essays/the-ubiquitous-matrix-o....

This reminds me of the Kurt Vonnegut novel Galapagos, in which the human race evolves beyond the era of really big brains since they weren't doing us that much good after all and made our heads less streamlined for swimming after fish.

I'm using it to simulate Ajax calls from HTML files that are being stored to disk and loaded via file:// URLs. Those can't normally make Ajax calls due to security measures in the browser, even in cases where they would only be making those calls back to the server where they originated.

Nice work! Can you describe the process?

This seems quite consistent with the idea that microtubules are the locus of the real action of consciousness and memory. The amyloid theory would then be confusing cause and effect. If that's so, plaques don't cause Alzheimers; they are the side-effect of a process that causes Alzheimers: disintegration of microtubules.

Related: I'm making a program in Go to inline all the resources for a web page so it ends up being a single file that you can work with offline more easily: https://github.com/ijt/inline.

Finite memory just means a limited subset of what a Turing machine can do.

Concurrency doesn't make Turing computable processes capable of anything beyond what they can already do. At best it buys them speed, maybe some expressiveness for the programmer, and bugs.

Nondeterminism is useful for some algorithms but it also doesn't make it possible for Turing computable processes to go beyond Turing computability. See for example https://arxiv.org/pdf/cs/0401019.pdf.

The most interesting item in that list would be the senses of organisms, as some of those might indeed involve processes that are not computable.

Also, some aspects of the brain's activity may not be computable. See Roger Penrose's books for details, such as p. 377 of Shadows of the Mind (a section about possible noncomputability in some physical processes).

This quote stood out as sounding quite far-fetched: "on many CPUs the interpreter consists of two or three machine instructions". Can someone point to an example?

I ask because they have a warning on their doc site saying that the web version is experimental and can crash. I'm mainly wondering how much that happens in practice.

That's interesting. Maybe heuristics would be useful for this. Like showing the issues ordered by some measure of how much discussion they have had, etc.

I like its RPCishness, but it also seems to require a lot of repetitive coding.

I see. So it's a face-saving way to talk about this. That seems plausible.

We're using Typescript with typeorm and a Postgres backend. The backend speaks graphql to a frontend written with Typescript and React.

Pro: Lots of people seem to be doing it this way, so there's plenty of info out there and it's probably easier to hire more people to work on it.

Cons: It's easy to make mistakes about authorization and even just wiring things up since typescript's type system doesn't catch some bugs that it seems like it should catch. It's tedious compared to postgrest, at least from what I've seen so far.

This has indeed been my own experience. I do wish we could get rid of our ORM and use Postgrest instead but the opinion was put forward that we won't be able to hire people who can write correct SQL.

I cannot upvote this enough. Why do these companies pay us all this money and then burn it with this nonsense?

I'm running https://zerosearch.io on a single 16gb standard instance with 6 vcpus on Digital Ocean with the "Ubuntu Docker 5:19.03.1~3 on 18.04" image. The memory is important to keep an index for the top 1000 github repositories. It could probably do just as well with only one or two CPUs. The app is made up of two Docker containers: the indexer and the webserver. I'm using Cloudflare, which makes the site a lot faster and greatly reduces load on the webserver. For now there is no database. The code is a fork of https://github.com/google/zoekt, written in Go.

The stack is simple and easy to work with, locally and in prod.

If you want to jump directly to the image, here it is: https://www.youtube.com/watch?v=Dr20f19czeE&t=8m28s

If it's better, why not submit a pull request to PostGres and try to make it the default output style?

If you think about Facebook as an empire, it's worth considering that people who have lived under empires don't generally go back to living as they did before the empires showed up. They typically want a better empire to live under.

In a country with millions of voters, a single vote isn't likely to be what decides who gets elected. In the limit of infinite voters, casting a vote is a lot like pressing a placebo button. It's not directly useful for the voter, but it makes the voter more likely to accept the outcome.

"people more readily obey a system which purports to heed their input". Sounds like democracy.

Rocket stoves might be a way out of this, since they produce nowhere near as much smoke as a conventional fireplace. That's because the airflow around the wood in a rocket stove is mostly laminar rather than turbulent.

https://en.wikipedia.org/wiki/Rocket_stove

If I only want what others seem to want, then where did all the wanting begin?

Here's a way to apply this idea to an open source project. The issue tracker could allow people to submit bugs, but a cron job running once per minute would move all the externally submitted bugs to an internal bug tracker that only the developers on the project could see. Then the independence assumption would be closer to being satisfied.

Evolution is spontaneous generation over a long time scale.

The linked article at https://www.researchers.one/article/2018-10-6 seems well-argued, nothing outlandish. It doesn't talk about anything in quantum mechanics though. I was hoping to find that somewhere.

Isn't this just because withMyResource returns IO a rather than IO ()? It doesn't seem reasonable for it to return the resource.