I found this as a running process on my machine. It was installed as a dependency for another package and adds an autostart script. It does not come with a default log viewer as far as I know (it needs something like gnome-activity-journal for viewing).

The startup school's About page says there are office hours every week

> Class Office Hours will also be held each week to give live advice and feedback to the class.

but that schedule only has office hours planned for weeks 2, 5 and 9. Is one an update of the other? Are there any office hours the first week?

Sorry about that. Initially we were going to have on-stage office hours every week, but we have since changed the format for the course. Those office hours in the most recent blog post are current; we'll update the site now.

Apologies for the confusion!

I don't know but I'll ping sandslash for you.

Nice project. What do all the

//> SomeName not-yet

in the code mean? Are they meant for some kind of automatic processing? Its a bit hard to read with all of them there...

Sorry, yeah. Those are the markers that the build script uses to insert the code snippets in the right place in each chapter.

I know it makes the code hard to read. I should probably slap together a little script to strip them out.

> Basically, exec and eval don't work. Since we don't use those in production code at Google, this seemed acceptable.

What about stuff like literal_eval? Or even just monkeypatching with name.__dict__[param] = value ?

> It does fine grained locking. Mutable data structures like lists and dicts do their own locking. Incidentally, this is one reason why supporting C extensions would be complicated.

Would there be a succinct theoretical description of exactly how that's implemented anywhere? What about things like numpy arrays.

> > Basically, exec and eval don't work. Since we don't use those in production code at Google, this seemed acceptable. > What about stuff like literal_eval? Or even just monkeypatching with name.__dict__[param] = value ?

literal_eval could in principle be supported I think. name.__dict__[param] = value works as you'd expect:

  $ make run
  class A(object):
    pass
  a = A()
  a.__dict__['foo'] = 'bar'
  print a.foo
  bar

EDIT: fixed formatting

Hmm, numpy isn't pure python, is it? If I read correctly this only works with pure python.

By volume numpy is mostly assembler written to the Fortran ABI (it's a LAPACK/BLAS-etc wrapper).

NumPy is a library that provides typed multidimensional arrays and functions that run atop them. It does provide a built-in LAPACK/BLAS or can link externally to LAPACK/BLAS, but that's a side effect of providing typed arrays and is nowhere near the central purpose of the library.

Also, NumPy is implemented completely in C and Python, and makes extensive use of CPython extension hooks and knowledge of the CPython reference counting implementation, which is part of the reason why it is so hard to port to other implementations of Python.

Having typed arrays without efficient functions over them would be rather pointless.

Are you sure you aren't mistaking numpy for scipy?

numpy is the foundation of scipy.

Thank you for writing this (and your last comment) out explicitly. The quantum mechanics description confused me (and possibly other from reading the thread here). Although I can understand how that inspired this work in the first place.

The algorithm used is exactly what you described here. It wasn't obvious to me that probability density functions were not tracked (the algorithm only tracks which NxN patch are allowed at each location) and randomness only come into play when a random valid choice is made, and there each valid patch is chosen probability proportional to its number of occurrence in the input.

Is there any instructions for getting the Frank system (that you show off at talk) on a Linux computer? Even instructions with some missing steps to be filled in. It would beat recreating things from scratch from glimpses.

I find it much easier to explore with a concrete copies that can be queried with inputs and outputs, even if they are far from their platonic ideals. For example, the Ometa interpreter I wrote recently was much easier to make by bootstrapping the creation of an initial tree from the output of an existing implementations of Ometa.

Is there any way to filter by the values? Namely average length and frequency? Other than by eyeballing, of course.

I hope this site catches on!

Is there any tool to search for podcast by length or format?

I really like the Writing Excuses podcast (from suggestions on HN) and would like to find others in the same format on different topics. Short podcasts with well thought out analysis and answers.

I think getting this (https://github.com/3b1b/manim) to work needs a video would need a video of its own. :)

Here's where I got to since the README.md is basically empty for the moment.

So far I've got it to do something. It needs at least these python libraries as dependencies.

    - cv2 (This is OpenCV and is not easily installable inside virtualenv)
    - colour
    - progressbar
    - tqdm

I'm running everything from the main manim directory, after a git clone.

    git clone https://github.com/3b1b/manim
    cd manim

Its also expecting a `../animation_file/images` directory to exist.

    mkdir -p ../animation_file/images

Now each project consist of a set of classes, each one a scene. To view a scene, it can just be instantiated

    PYTHONPATH=`pwd` python
    >>> scene = generate_logo.LogoGeneration()

There's a progress bar that shows a few times. Then a new window shows up for me (from ImageMagick? Maybe that's a dependency too.).

Then I think you can call .construct() on the object.

    >>> scene.construct()

But it took too much computational power so I stopped there.

Ah, yes, this is one of those projects that I worked on mostly as a tool for my own use. Eventually, I plan to make a proper tutorial and everything, but first there are a few key things I ought to revamp which, over time, have become way over-personalized.

I like that lambda trick. I was hoping Crash would actually crash the program so you could tell if you won by looking at the error it gives (if its KeyboardInterrupt or something else).

Here's mine.

  $ python -c 'import random;L=sorted(str(random.randint(1,9)) for i in range(4));a=raw_input(L);print(eval(a)==24,sorted(filter(str.isdigit,a))==L)'
  ['2', '6', '7', '8']8*(7+2-6)
  (True, True)

Try to make it print (True, True) without abusing eval too much (intended to be +-*/() only with digits as tokens).

A nicer interface, but too long:

  import random;L=sorted(str(random.randint(1,9)) for i in range(4));a=raw_input(" ".join(L)+"\n> ");print(eval(a)==24,sorted(filter(str.isdigit,a))==L)