undershirt

Would this be a good way to learn a language? Seems like a good way to show how to pronounce consonants/vowels that we may have trouble discerning from similar sounds.

for example, I would love to be able to refer to this when watching Erik Singer describe accents: https://www.youtube.com/watch?v=NvDvESEXcgE

thank you for posting this, fascinating

I just want to say great work. The parent comment here didn't realize that you drastically improved the user experience by showing the stack, which I think makes all the difference here.

To make this clear, I would upload your video to gfycat and link the gif in your readme.

> Note that string delimiters in Dern are [ and ] and not "; this way dern code can be written inside C-programs without escaping.

Interesting approach. I suppose this makes whitespace inside square brackets significant. And quotes inside of these brackets would have to be escaped if written inside C-programs.

This is probably difficult to explain without proper context, but could I ask you for a summary? (Thanks for the book references.)

How would we specify P? I can't get away from the idea that specifying P is similar to constructing T.

> human nature, which has not changed much over the last 500 years

Let's be clear that "human nature" is relatively stable, but the "cultures" that sit atop are much more capricious-- slowly changing in different ways to fit the same human desires.

Reminds me of Agent Smith's speech on the failure to build a utopian matrix. Can we ever find solutions to problems that only manifest later? In other words, if we can't get to utopia by iterating on locally rational decisions, we may need AI to help us. Convincing ourselves to follow its advice may introduce new problems.

Once, when waking from a nap, I was able to consciously keep my "dream eyes" open with my real eyes closed. I could vividly see images my dream was still generating, and it looked a lot like this.

Makes me wonder if I'm just influenced by the work happening in ML, or if we are really approaching what the brain is already doing.

Oops, didn't realize that seamless does its own shallow copying strategy with `merge`, `set`, `setIn`. I can't speak to how this compares to persistent data structures implemented by immutable.js, clojure, elm, etc. But it looks like the seamless author said the following about it:

> Persistent data structures are different, as their performance improvements are passive. Although seamless-immutable does not (and cannot, while maintaining its backwards compatibility with vanilla JS collections) use things like VLists under the hood, its cloning functions—such as merge—only bother to make shallow copies, as shallow and deep copies of immutable values are equivalent. In practice, this simple passive optimization has been sufficient; we have yet to encounter a performance problem that Bagwell-style persistent data structures would have solved.

from: http://tech.noredink.com/post/107617838018/switching-from-im...

It's interesting that contradiction, that is inconsistency, is a hint that a mathematical system does not model something in reality, because we don't want to believe such a thing can exist. But it is about as hard to work out the kinks of inconsistency from of a mathematical model as it is from ideology, law, ethics, and other such systems that we construct to guide our behavior. So I would say that METAmathematics has a lot to say about us and our ability to construct consistent systems-- it's really hard.

Freedom is one such example since it cannot belong to everyone when competing interests are at play. That might be a strange way to slice it though, since the language we use to describe freedom is probably not as well defined as we think.

seamless doesn't implement the "persistent" part of immutable persistent data structures. The persistent part means you can create a cheap modification of the data structure, with structural sharing between "copies".

Both were stated in the video. seems contradicting:

- https://youtu.be/iPILIf7ru48?t=4m4s

- https://youtu.be/iPILIf7ru48?t=8m11s

Cool, I used to volunteer in high school, but I used local clubs there to find those opportunities to help. Where do you go?

An aesthetic just seems like a unconscious favorable reaction to stimuli based on genetics and culture. Why our genes and culture have favored certain forms, I suspect there isn't a way to reduce it to something satisfactory.

I used to wonder why I felt good when looking at sunsets, landscapes and clouds. But I figured that our aesthetics probably evolved in response to what was around us. Happier people probably survive better.

The way we hear music seems like such an aesthetic, as it might've occurred within ancient cultures as a form of play and release. I suspect that our random genetic hunger towards different aesthetics might have created an incredible developmental feedback loop. I'm not sure where I'm going with this incredibly complicated topic, but I have a lot of very unrefined thoughts about them, that are probably overly-reductive and wrong.

So, good sellers appeal to bad buyers.

Thanks, I actually don't have a general solution for doing this. The code in the slide is specified with markup, so the usual events apply for detecting mouseover.

i'm adding three more slides to flesh out the trickier stuff soon

Thanks, this is very interesting! I added it to the article.

The only difference is that bounding boxes are still used for sprites, but he adds a sort of voxel heightmap inside of it to represent occupied volume.

> heightmap: https://youtu.be/Ssrkq6_6JYU?t=15m21s

If you imagine this heightmap as a building with multiple floors (e.g. 1st floor, 2nd floor) the algorithm takes the lowest common floor of each of these buildings and performs an intersection test between them and nothing else. This allows the sprites to interact more fluidly inside the bounding boxes! Neat.

> heightmap floors: https://youtu.be/Ssrkq6_6JYU?t=16m12s

Please delete that third paragraph. However minor you think it is, they spoil some of the serendipitous experiences that are important to the game.

FYI: I was reading the README to understand what Kalman Filters are. This section seems to end abruptly mid-sentence at "You might imagine" without explaining what Kalman filters are: https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Pyt...

> To say that I was treated pretty shabbily by David Nolen on this issue almost goes without saying

He maintains projects by trying to triage issues in an efficient and emotionless manner. I wouldn't take it as rude though.

"Hush" immediately came to mind as a useful name for an invisible language.

I don't think the author realizes how appropriate the Jedi tone for this article is. Comprehensions are the gateway drug to the dark side, away from imperative programming and toward languages that treat everything as expressions which snap together more freely. It hints at an idea of making a `for` loop and an `if` statement return a value (see CoffeeScript). But it also hints at the idea that useful idioms like the List Comprehension can merge/simplify existing constructs into a new, easier syntax-- and that there are languages that allow you to do this freely (see Lisp).

Python showed me the Force, but I'm with the Dark Side now.

It'll depend on the codebase of course, but I think it's a lot less work if you're using the flux frameworks that seem to be popular with modern JS apps.

I think it's interesting that Elm and ClojureScript have chosen immutability as the default. I wonder what other languages have chosen this.

> ... they use typography like bold, italic and greek symbols that you have to replace with the uglier reality to distinguish between things like s-expr from lists.

My main complaint with Scheme is that it's hard to distinguish a "call" from a plain list. For example, in `(let ((foo 1) (bar 2)))`, `let` is a call, but `foo` and `bar` are just being assigned, not called. Clojure uses `(let [foo 1 bar 2])`, so you can tell that `let` is a call, but `foo` and `bar` are now unwrapped and placed inside square brackets to signify plain data, not a call.

> To give clojure a whirl, ... there were so many non-s-expr syntactic special cases for things like list comprehensions and common macros

Everything is still an s-expr. The square and curly braces still follow the same rules, but they just mean they are not "calls" like parens would normally signify.

For a list comprehension example: `(for [m messages] (str m))`, `for` and `str` are calls and `[m messages]` is just data. It could be unwrapped like `(for m messages (str m))`, but it's wrapped in square brackets as a visual indicator for what's important. But if it was wrapped in parens like in Scheme, it could be confused as a "call".

Clojure is very well-designed to solve visual problems of Scheme and other Lisps. I recommend looking at it again :D

I think this is great. A WebGL version of this would be great too

lisp has many dialects. try searching "webcrawler clojure"

Thanks for posting! Great to hear him talking about this.

to Notnow:

> Jade can be used along with code too. I think that you mean view logic by code here as mixing business logic with your view is a big no no.

Code is data. Separating concerns by using different technologies to solve the same problem is not simplification. You can separate views from logic as you would separate different functions in code. We can organize that.

> I took a look at Hiccup. It looks interesting and promising but I'm an indentation oriented developer and that's why I favor Jade and Sass and the likes.

Not liking Hiccup because you prefer indentation doesn't make sense. Hiccup is indented by convention. If you're speaking about the delimiters, those are what keeps it from slipping into limitations shared by JS, Jade, etc.

> Also, I like the design philosophy that they chose with Jade by absorbing JS in HTML and not the other way around like in JSX where HTML & CSS being subordinates to JS thus making the process a whole lot more tedious and time-consuming.

You don't need to choose an absorption direction between JS and HTML if you treat HTML as what it is, a nested data tree, and realize that templating is the mixing of logic into this data tree. S-expressions in Lisp were designed exactly for this.