gregdetre

Language learning app for intermediate learners who want to practice reading and listening:

- As you're reading, AI helps you with words it thinks you might not know

- Highlights etymologies & mnemonics

- Shows you words in their natural habitat, e.g. listen to example sentences

https://www.hellozenno.com/

I'm trying to read a kid's version of The Odyssey in Greek and to be able to understand my partner's mum, and these are the features that I wanted.

Also, I wanted to experiment with "what would an app like this look like if we could trust AI to be very cheap/fast/correct?".

- So, for example, it's a fully generative dictionary & search, e.g. the dictionary entries/metadata/example sentences don't exist until the first person searches for them!

- You can upload any kind of content (image, audio, text), and it'll automatically transcribe, translate, annotate, etc.

Hmmm, interesting. That hasn't been my personal experience.

The evidence suggests that brainstorming doesn't work so well - the loudest and earliest views tend to dominate.

Instead, the recommendation seems to be to allow people to generate ideas in silence first. This is my approach, which has worked very effectively in groups of up to a dozen remotely for a variety of questions:

https://www.makingdatamistakes.com/how-to-run-an-idea-stampe...

Cool! Drop me a line at greg at gregdetre dot co dot uk

Fluid Concepts & Creative Analogies ch 4-6 are the best introduction to his modeling work. I can't recommend them highly enough.

Building on Hofstadter's models of analogy-making to build pattern recognition algorithms that work in a more human-like way. At least, that's my hope!

My background is in computational neuroscience, but I'm doing this on my own, mostly for fun. If it sounds interesting, I'd love some company! greg at gregdetre dot co dot uk

I've been using 1Password for a few years now. I'm not qualified to comment on the security aspects of it - I'm trusting them and Apple to take care of that.

But I can comment on the superb quality of the user-facing aspects - it's a pleasure to use, has great iPhone and Dropbox support, and I really like the way they communicate as a company.

I'll second that.

Furthermore, Sauce Labs offer servers running lots of different OS/browser combinations that you can run your Selenium tests on.

In other words:

- we write our Selenium tests in Python (assert that when you click, X happens)

- they get run on our continuous integration server every time we push to GitHub

- the Selenium tests fire up IE 8 on Windows on a Sauce Labs server and run themselves

- the output gets piped back to us as part of our unit testing suite, emailing us if any of the tests fail

Well, we almost have it working as well as that :) Either way, we've been really impressed by Sauce Labs so far.

I'd be totally fascinated to hear about this if you ever find it! I'm greg at memrise dot com.

There's lots of evidence to show that mnemonics boost recollection by a factor or three or so across a wide range of domains, abilities and time ranges. See e.g. http://www.unforgettablelanguages.com/studies.html

Re the intermediate mnemonic device, here's the way I picture things. The mnemonic provides training wheels for your brain, helping you get the answer right a few times. Then, after enough correct responses, mediated by this (hippocampal) mnemonic representation, you rely less and less on the training wheels, and your cortex has had a chance to form a longer-lasting and more direct semantic link.

Disclosure: I'm one of the co-founders of Memrise, so it's not too surprising that I think there's merit in this approach :) Drop me a line or reply here, and I can try and follow up in more detail. Maybe I should write a blog post...

If you're in London, drop me a line - greg at memrise dot com.

And even if you're not, take heart - some of the best people I know have been in this situation at one time or another.

Broadly, our scheduling algorithms are based on the same ideas of spaced repetition that inspired Anki, SuperMemo and lots of others, though the devil is often in the details.

http://www.wired.com/medtech/health/magazine/16-05/ff_woznia...

However, neither Anki nor SuperMemo enrich and speed up your learning with mems (crowd-sourced mnemonics), which provide a huge and well-documented boost to your learning rate and retention.

Perhaps most of all though, we've worked really hard to make Memrise a really happy learning experience. It's harder to put numbers on that, but hopefully you can feel it when you try it!

Thanks for the positivity. We have an iPhone app coming out in the next 10 days. Definitely let us know what you think of it if you try it.

Sentence building is definitely on our radar, but it's a rich and thorny domain, and we want to take our time coming up with something good.

P.S. Android is going to take a little longer.

We added the garden narrative in Spring 2011. The goal was to wrap our internal model of the state of your memories in a visual metaphor to make it clearer and more vivid for you as a learner.

We've improved the underlying algorithms a lot since then. Do let us know if you still find the garden confusing.

This is a great question.

In our experience, we've found that creating your own mnemonic is usually the best way to really deeply encode a new memory.

But a great mem from someone else works almost as well. And it's a lot easier to breeze along, giggling at other people's imagery, occasionally coming up with something new of your own.

Forgive the plug:

http://www.memrise.com/item/3190/impecunious/

That sounds promising. I'll take a look.

P.S. I'm at greg at memrise dot com if you make further progress and are looking for beta testers.

We've tried 2 or 3 existing Javascript error tracking systems in the past. None of them helped much.

Performance is not the feature I care about.

On the other hand, I would be delighted to pay to get more actionable information about our errors. It's so so hard to determine exactly where in the code, and under what circumstances, errors in the browser happen.

iOS - London - full time - Memrise - http://www.memrise.com

We're seed-funded, just out of TechStars Boston, and we have thousands of happy users, clamouring to hear about progress on an iPhone app.

If you like the idea of a deeply creative, technically demanding role in a company that aims to make all learning fast, fun, mobile and effective, please send an email with CV or questions to jobs at memrise.com.

Join us in our mission to give the world a better memory.

Some forms of short-term storage are volatile, like RAM. They store by coaxing the neural activation into a stable attractor - as long as all the neurons keep firing in sequence, the memory stays alive. This is fast to create, since it doesn't require any hardware writes (changes in synaptic weights).

In contrast, long-term storage involves permanent changes in the synaptic weights between neurons, which survive any fluctuations in activation, and can then subtly influence computation ever after.

And for medium-term storage (from minutes to months, say), you have the hippocampus, which has a big hash table of pointers to long-term structures.

Of course, this is all a huge simplification :)

If you're interested in pursuing this, I'd start here (Ken was my former PhD advisor, but I still think this is a rich but comprehensible introduction):

http://psych.colorado.edu/~oreilly/papers/OReillyNorman02_ti...

It's also very, very high-dimensional. Imagine a gigantic space, where similar thoughts could be placed next to one another. Thinking would be moving around this space. Free association would be taking a step or two in a random direction. Comparison would be a vector.

This captures a little of the nature of semantic representations (storage of meanings and concepts). But of course, semantic representations differ hugely from, say, representations of a tennis serve, or the phone number you're repeating under your breath while you key it in...

There are so many differences that one's standard intuitions as a computer scientist can be very misleading...

I wrote on this elsewhere:

http://blog.memrise.com/2011/05/how-is-memory-stored-in-brai...

http://blog.memrise.com/2011/05/how-are-brains-different-fro...

For instance:

- Storage and parallel computation in the brain are very expansive and cheap, so the brain prefers to store rather than compute where it can.

- Above all, the brain's storage is highly content-addressable. Similar things in the world are stored with similar representations, so that the brain can generalize, and see commonalities. This is not a graph - graphs are discretized - this is much more flexible.

- Even the acts of storage and retrieval are themselves a kind of computation, a transformation, a compression and a learning experience.

- Memories are not clean silos. Storing a new memory can subtly (and not so subtly) affect other nearby or related memories

- Different parts of the brain use different storage parameters. For instance, the hippocampus is like a hash table, storing each memory relatively cleanly and in isolation, but can only be accessed with exactly the cue. In contrast, the cortex stores memories in a much more content-addressable, overlapping way that's invariant to many small differences (e.g. we can recognize a face whether it's rotated, sunny, tanned, close up, obscured).

This looks interesting - we've been pretty happy with crossbrowsertesting.com until now, which is also worth a look.

Here's what I'd love next - we'd write a bunch of QUnit javascript tests, put them behind a private url on our staging server, and then be able to run those tests from the command-line on multiple browsers (through BrowserStack, say), and spit back the output in a form that Jenkins understands. I'd certainly pay $20/month for that, and maybe more if it was great.

Inter-subject variability is a huge problem in this kind of work.

As you say, they're operating at a much larger scale than individual cells (100k-1m cells in each voxel). Likewise, some early visual processing areas are broadly organized kind of like big, noisy bitmaps on the surface of the brain.

But for sophisticated machine learning-style analyses like these, the gross differences in representation and morphology (especially at higher processing levels in the brain) make it very hard to pool the data across multiple people. That's why they're preferring to use many sessions from a small number of participants rather than a single session from many participants (the standard approach).

[I worked on applying machine learning methods to fMRI for my PhD]

See:

https://github.com/jperla/pebbles

https://github.com/memrise/pebbles

While I think you're right, this is still pretty astonishing.

It's important to note that they're generalizing from a few hours of training data to millions of videos. So the classifier has to be picking up on something deep for it to be re-applied in such a flexible way.

I sort of imagine this approach as being akin to the way Bumblebee (the yellow VW Beetle in the first Transformers) lost his voice, but was able to communicate by switching between radio stations. As that recomposition process being richer and richer, it starts to approximate the real signal...

It's a good question. I don't think I'll have an informed opinion until we've experienced what it's like to work in this way for a while.

But:

- Joseph Perla's suggestions are usually good

- It just feels better to me... Maybe because it's easier to auto-generate html (e.g. from a Django template). Maybe because now many of our pages won't need any javascript. Maybe because all the custom logic is in one place rather than spread over the html and the javascript. Maybe because writing javascript is harder than html :)

It's a clever idea:

- In your html, you annotate objects (e.g. a button) with the '.actionable' class

- Then provide a set of arguments in the html alongside, e.g.

        <div class="kwargs">
            <!-- replace #money with the output from /user/3/money/create -->
            <input name="type" value="replace" />
            <input name="target" value="#money" />
            <input name="url" value="/user/3/money/create" />
        </div>

- The library then parses the html of .actionable objects, and automatically creates the relevant jQuery bindings for you. In other words, you define the behavior in html, without having to write any custom javascript.

We're experimenting with a few ways of extending this on Memrise (Spencer Davis gets most of the credit here). It's early days, but we're an ajax-heavy site, and devolving certain kinds of basic, repetitive functionality to html feels natural and simple. And, by adding new handler types to the library, it becomes much, much easier to create reusable widgets that we can sprinkle throughout the site.

P.S. Currently, most of this work is still on a development branch that will be live within a couple of days.

Thanks for this code. We'll look over it carefully to see if there are some tricks that we've missed.

But we've tried many libraries, and many approaches, to monitoring and debugging javascript. The browser is a much more hostile, varied and foggy environment than (say) Python. It's much harder to notice when something goes wrong, which browsers and which pages it's common to, narrow it down to the right subset of circumstances and contexts, and then effect a fix.

You can try sending an email every time you catch a window.onerror, but most of what you receive will be irrelevant or inscrutable.

If Proxino can make more sense of things, they could make a huge difference to rich-front-end development.

[I don't know them, I've not yet checked out their product, I'm just trying to persuade you all that they're trying to solve a meaningful (at least to me) problem]

Hi there. I'm Greg, CTO of Memrise.

Feel free to ask me about the science if you'd like. It's hard to strike a balance between advertising what we think is most important and comprehensible, and sounding too mystical.

Sorry about the disappearing splash page - I know what you mean, and we'll have to think about a better way of letting people get back to that, while still making the dashboard for logged-in users primary.

Yours, Greg

Oh, and pythonistas should check out Django Zoom (Heroku for Django) - they sit about 50 yards away in Dogpatch, and they offer an amazing 1-click deploy for Django.