somlor

Immediately after WW2 all fascists worldwide disappeared in a poof of smoke. Also their rise to power has always been abrupt and without warning via an on/off switch.

The "43 Group" comes to mind. https://vimeo.com/64299989

Thanks, digging them already.

Some recent favs:

- https://www.youtube.com/watch?v=w5eQuhBfDE0

- https://www.youtube.com/watch?v=uHlZA5OYj2I

- https://www.youtube.com/watch?v=1WeeMHq3I3Y

- https://www.youtube.com/watch?v=bsFM7kj0RII

- https://www.youtube.com/watch?v=6ekRLVXIIpw

- https://www.youtube.com/watch?v=wlFeOy-I2MY

- https://www.youtube.com/watch?v=87Qqk_wNFOk

Another +1 here. Intense visceral disgust of lavender. I don't think I'm "smell-sensitive" in any other way. I can tolerate all manner of, e.g., dank cheese, pungent fish, fragrant smoke, any other plant oil, etc. I just can't stand lavender.

ClojureScript with re-frame is fantastic. I also use it on a production app with an Elixir backend, it's a great fit. Be sure to check out re-frisk and re-frame-10x.

As an Elixir dev I tend to agree. I've found ClojureScript to be a nicer fit (Reagent with re-frame if needed).

Your gist link under functional programming support is a 404 for me.

Just a note that in your "Final Thoughts" you're linking to the 1st edition of "Mastering Bitcoin" but there is a 2nd edition now.

ClojureScript itself fits wonderfully in Elixir/Phoenix land. :)

Please never hijack back button.

I think I see where you're coming from, but I also think you might be moving the target a bit. I suspect you'd garner less debate if you said, I dunno, just "a dynamic UI app needs a way to model state changes". "Mutate" has a specific meaning, in my mind at least, when discussing variables and data structures. React enables avoidance of direct DOM manipulation, Redux obviates direct state mutation.

The DOM can be mutated just fine behind the scenes by React to reflect whatever brand new state has been passed into it. That brand new state can be anything. It can be a single (by definition immutable) integer. It can be a deep clone of an object. This is the ideal intended Redux architecture. Redux reducer(s) receive the state and return either the state untouched, or a non-mutated copy of the state. React reacts accordingly by expressing this brand new state as (possible) DOM mutations.

> If you haven't mutated states, you don't have an interactive UI.

React allows you to treat DOM mutation as an expression of current app state.

This doesn't mean that your state itself has to mutate. It's entirely possible to structure a React (and/or Redux) app with fully immutable state, copies of which represent change. (Whether copies are done efficiently, e.g. via persistent data structure algorithms, or naively, e.g. via a deep clone, is secondary).

I'm befuddled where you're getting the impression that immutable data structures themselves require mutation.

Another nice option is kiex, Elixir version manager: https://github.com/taylor/kiex

Sure. My reasoning: The localStorage token helps protect against CSRF, e.g., this token will not be submitted via a form embedded on another site (cookie will), therefore request will not be authenticated. In an XSS attack (aka "we're screwed"), the secure, HTTPOnly cookie at least adds an additional level of complexity above simply reading a single plaintext localStorage item. Perhaps this is naive? Of course I also take every precaution to prevent XSS from happening at all. Relevant[1].

---

[1] http://www.redotheweb.com/2015/11/09/api-security.html

For single-page apps I use two session tokens. One in localStorage (csrf_token), one in a secure, HttpOnly cookie (auth_token). Both tokens are required for the API to authenticate a request.

My fiance and I moved from the Bay Area to Asheville, North Carolina last year and could not be happier. The only checkmark missing is decent transportation outside of cars.

    * https://www.google.com/search?q=asheville+downtown&tbm=isch
    * https://www.google.com/search?q=asheville+autumn+leaves&tbm=isch

ᕦ(ò_óˇ)ᕤ

I prefer DTerm[0].

From Finder, ⌘⇧⏎ pulls up an Alfred-like modal for executing one-off commands in the folder you are viewing, displaying output in the modal itself.

Another quick ⌘⏎ pops open a full terminal with the folder as your working directory.

[0]: http://decimus.net/dterm

I've been using https://snipt.net for the last 6 years.

I would highly recommend anyone interested in doing a 10-day vipassana retreat, particularly their first, to look into Insight Meditation Society[0] (outside Boston, MA) or Spirit Rock[1] (near Marin, CA). They're not free, but you get access to extraordinary teachers and impeccable guidance.

  [0] http://www.dharma.org/meditation-retreats/retreat-center    
  [1] https://www.spiritrock.org/retreats

Postman Launcher is pretty handy: https://chrome.google.com/webstore/detail/postman-launcher/i...

For anyone still lurking, this user replied to me via email:

Ruby allocates heaps for its objects, and sets GC thresholds based on those heap sizes. Ruby allows you to change those settings via environment variables, which means that you can end up doing fewer allocations and less aggressive GC, which makes sense when using a full framework like Rails, which is going to allocate a lot of objects.

There's a more complete answer here to get you started: http://stackoverflow.com/questions/13387664/ruby-gc-executio...

> make sure you're setting higher GC limits for the Ruby tests

Could you elaborate on this, or point me in the right direction? I'm learning Rails and curious.

Another interesting and relevant read: http://marshallbrain.com/manna1.htm

Paydirt (https://paydirtapp.com) - Time tracking and invoicing.

SerpBook (http://serpbook.com) - Search engine rank tracker.

Mortar (http://mortardata.com) - Hadoop-aaS.