davidkhess

I don't think storing authentication tokens in people's email is good UX and raises expiration issues.

Here's another take on how to get rid of passwords: The Password Manifesto

http://www.tech-spelunking.com/home/2014/9/5/the-password-ma...

The abstract:

Interpreters have a bad reputation for having lower performance than just-in-time compilers. We present a new way of building high performance interpreters that is particularly effective for executing dynamically typed programming languages. The key idea is to combine speculative staging of optimized interpreter instructions with a novel technique of incrementally and iteratively concerting them at run-time.

This paper introduces the concepts behind deriving optimized instructions from existing interpreter instructions---incrementally peeling off layers of complexity. When compiling the interpreter, these optimized derivatives will be compiled along with the original interpreter instructions. Therefore, our technique is portable by construction since it leverages the existing compiler's backend. At run-time we use instruction substitution from the interpreter's original and expensive instructions to optimized instruction derivatives to speed up execution.

Our technique unites high performance with the simplicity and portability of interpreters---we report that our optimization makes the CPython interpreter up to more than four times faster, where our interpreter closes the gap between and sometimes even outperforms PyPy's just-in-time compiler.

Whoops. That was a presumption on my part.

I've used Durus a lot (a simpler version of ZODB) and indexing was always the biggest issue I ran into. Normal object associations don't need traditional indexing but object lookup based on attribute values gets pretty painful without some indexing support.

If you are interested in object-oriented databases for Python check out Durus: https://www.mems-exchange.org/software/DurusWorks/

It's design is based on ZODB but with a number of simplifications and no dependencies on Zope.

I've found the most critical difference between OO and FP to be state. Objects are stateful from the moment they are created until they are destroyed. FP is remarkable for its general lack of side-effects - i.e. computations do not normally affect shared state.

I believe this distinction is a critical one because an application with a lot of shared state is more difficult to scale than one without. As another poster pointed out, in a shared addressed space such as a desktop app, this isn't a concern. But if you want to scale an application across multiple address spaces, communicating and synchronizing the state of objects between these spaces tends to be difficult.

So, my tendency is:

Small and shared address space? Tend to use OO patterns and implementations.

Big and distributed address space? Tend to use FP patterns and implementations.

Note, I don't consider OO vs. FP a language choice – I consider it a programming paradigm choice.

Is this Ars Technica's 2013 version of the "War of the Worlds" radio broadcast scare in 1938?

Does anybody have a read on how many browser-based password managers are going to be affected? (if any)

My login to the Bug Reporter is currently broken but I'll definitely report it. Thanks!