4 Matching Annotations
  1. Jan 2020
    1. Together we can continue to revise resistance

      Robert Twigger has a great book about learning called "Micromastery"

      I am trying to figure out what the entry trick is for this discipline called "teen activism". This is some of what I am seeing, but these are not really entry tricks so much as abstractions.

      1.peer audience? 2.finding student capacity? 3.enlarging the field of possibility? 4.teaching for social justice? 5.navigate and negotiate with students? 6.research tools? 7.create media?

      Not being critical here, but I am looking for the entry level trick to get my students into activism much like Twigger explains here with cooking eggs as an entry trick into the discipline of cooking.

      Is this too big an ask?

  2. Dec 2017
    1. If the entire tables are constant over a long time, you could generate them as modules. Nowadays, compile-time constants (even complex ones) are placed in a constant pool associated with the module. So, you could generate something like this: -module(autogen_table). -export([find/1]). find(0) -> {some_struct, "hello", ...}; ... find(99) -> {some_other_struct, <<"hi!">>} find(X) -> throw({not_found, X}). As far as I know, these constants will not be copied to the private heaps of the processes. The generated code will also give you the fastest possible lookup.

      This is a pretty cool trick. So looks like a way to bypass the copying overhead is to make a function that only has constant outputs and doesn't actually compute anything.

    1. To summarize: without queuing mechanism: same Erlang node: 5.3 million messages/min; different Erlang nodes: 700 K messages/min. with queuing mechanism: same Erlang node: 5.3 million messages/min; different Erlang nodes: 2.1 million messages/min. The complete code to run this on your machine is available here. This whole ‘queuing idea’ is still an experiment, and I’d be more than delighted to hear your feedback, to see whether you are getting the same results, you know how to improve the concept or the code, or you have any considerations at all you would like to share.

      I got here from the discord blog on how they optimized their performance and it looks like the trick is to batch messages when sending to remote nodes. Seems kinda obvious though that batching messages would improve performance.

      A trick to keep in the back pocket.

    1. After doing some research, we found mochiglobal, a module that exploits a feature of the VM: if Erlang sees a function that always returns the same constant data, it puts that data into a read-only shared heap that processes can access without copying the data. mochiglobal takes advantage of this by creating an Erlang module with one function at runtime and compiling it.

      This is a cool trick and it sounds like partial evaluation and just-in-time compilation.