etrinh

Cool project! I haven't seen the idea of drag and drop for building regex's before. I could definitely see this being a helpful tool for people learning regex. Some feedback:

1. The railroad is the intended drag target but is really small, especially compared to the other icons (giant trash can!). This makes it difficult to drag onto, and it's not obvious that that's where you should drag the blocks.

2. Black on brown (ie: railroad and trash can icons) is really hard to see.

3. Highlighting of the matched word (where the "Write text here!" is) seems to be pretty sporadic. It looks like highlighting only changes when the regex changes. I expected to be able to change this field and have the highlight update as I type.

4. Doesn't seem like you can edit the middle of a string in the matching word field (Try editing "Write text here!" to "Write helpful text here!") The cursor keeps jumping to the end of the string.

I used these docs when I was exploring the Immutable.js API! Very helpful, but Immutable just updated to v3 (your docs are v2), which introduces some breaking changes (for example, Vector is now called List). Would you mind updating your docs?

I've been using this library for a project, and here are my thoughts on it:

1. Immutable data structures are a huge win. I can't count the number of times I've been bitten by a bug caused by some subtle mutation that happened in a part of my code that I wasn't expecting.

2. Using this library for data structures everywhere, as a replacement for native JS arrays and objects, requires you to have discipline in naming your variables so that you can infer their types. Things can get pretty frustrating when you try to map over a Set, thinking it's a Map, for example.

3. The most annoying thing might be the documentation, which consists of a type definitions file and liberal comments. It's ok, but hardly a great interface for exploring the API.

Overall, liking the library so far. I think with good, searchable docs (with examples of API usage) this could be something really great.

The app is pretty confusing to use. For those of you stuck like I was, you actually have to complete the tutorial in order to add people and start "slinging."

This. To my knowledge, JS perf isn't an issue in any modern browser (even the crippled iOS webview). Improving the performance of DOM access and manipulation (not just on iOS) would be a much more fruitful enterprise and is something I would like to see all browser makers focusing on.

The interactive macro editor is a great touch. I don't know if this is prevalent, but this is the first time I've seen a tutorial interactively modify code in the editor for you. Instead of "here, type this into the editor above and see what happens," there will be a link to "click here to see what happens" and it will change the code in the editor accordingly. I think this is a good thing, because I rarely go and do the things that tutorials suggest I do, even if they are as simple as typing into an editor that is 2 inches above the text I am reading.

Absolutely.

Go. Read. This. Book. Now.

This is a must-read for any developer who wants to know Javascript better. This is the book that taught me everything I know about prototypes, method decorators, and functional programming in Javascript. Sure, I'd read countless other Javascript books, but Reg has a way of explaining things in a way that connected the dots for me. This is probably the only programming book I've re-read cover to cover a dozen times or more.

I'd also strongly suggest you throw a few bucks Reg's way for the ebook (PDF, EPUB, MOBI) version of this book. I only know Reg through his writing, but he sounds like a great guy. The fact that he's releasing this gem for free is pure madness on his part.

If you couldn't yet tell, highly recommended.

Love it. This is a great read on the evolution of a design and what goes through a designer's head as they're iterating on a concept. One thing that should particularly stand out is that the format of the article is a continuous loop of 1) Design problem followed by 2) How I solved the problem. This is how great designs are made: constant iteration.

What is more interesting to me is that it seems like one of the key things to generating this loop is identifying design problems. If you can't really pinpoint what is wrong with a design, how can you make it better? Here, Ian seems to get a lot of feedback from other people, but I'm curious as to what kinds of internal thought processes he has when trying to identify exactly where a particular design is lacking.

One heuristic that works for me is thinking about the context of a design. In other words, how did the user get to this particular screen? What are their intentions when entering this view? Almost no individual UI element is self-explanatory when it's devoid of context. Just thinking about what the user wants to do at this particular part of your UI flow can help identify ways in which you can make the design clearer and more in line with their intentions.

In any case, there are a ton of great design patterns to pick up from seeing how Ian thinks about problems. Every designer needs to read this.

A lot of great information here. I always knew that overqualifying selectors was bad, but it was always from a "clean code" point of view and not so much from a performance standpoint. Even more reason to avoid them now.

Although this is very interesting information, anyone reading this article should pay careful attention to the ending headline, "Is all this really necessary?" Odds are, unless you've produced some kind of CSS monstrosity, your CSS isn't the bottleneck in your website performance. Min and concat your Javascript, use appcache, local storage, etc. before prioritizing CSS performance.

This seems like a great starting point for anyone who is interested in designing a website with a strong emphasis on text content (think blogs, online magazines, etc). If you've ever tried to formally study typography, it can be pretty overwhelming. I'm a web developer with an interest in design, and type is one of those things that seems simple until you realize you have to understand it intimately at multiple abstraction levels (individual letterforms, lines, and blocks of text). Glad to see there's a resource out there that uses typography best practices and makes them sensible defaults.