

Stop Being Cute and Clever - craigkerstiens
http://lucumr.pocoo.org/2013/12/9/stop-being-clever/

======
actsasbuffoon
> Not many languages manage to implement map in a way that ["1", "2",
> "3"].map(parseInt) would result in [1, NaN, NaN]

It may seem counterintuitive at first, but it makes sense when you consider
the function signatures. The map function passes two arguments; the element,
and its index. The index ends up being used as the radix, which causes this
sequence of calls:

    
    
      parseInt("1", 0);
      parseInt("2", 1);
      parseInt("3", 2);
    

I'd recommend creating a higher-order function that takes a function and
returns a unary version:

    
    
      function unary(fn) {
        return function(arg) {
          return fn(arg);
        };
      }
    

Then you could use it like this:

    
    
      ["1", "2", "3"].map(unary(parseInt));
      // => [1, 2, 3]
    

I think the problem is that you assumed (not unreasonably) that
[...].map(parseInt) was an eta reduction of [...].map(function(e) {return
parseInt(e);}). Unfortunately it's not, which caused some unexpected results.
This would happen in any language where the map function passes two arguments
and the string-to-integer function has an optional second argument.

Consider the following Ruby (this is a really weird way to do it in Ruby, but
I'm trying to make the method signatures match):

    
    
      # This lambda has the same type signature as JavaScript's parseInt
      parse_int = ->(str, radix = 10) { str.to_i radix }
    
      # This converts the lambda to a block and calls it with each element
      # from the array, along with its index.
      %w[1 2 3].map.with_index &parse_int
      # => ArgumentError: invalid radix 1
    

As an aside, I'm a recovering JavaScript hater as well. I've mostly made peace
with JS, though there are still parts of the language that make my skin crawl
(See this gist for my favorite example:
[https://gist.github.com/actsasbuffoon/7323667](https://gist.github.com/actsasbuffoon/7323667)).
That said, there are some parts of JavaScript that are genuinely great. I
recommend reading JavaScript Allongé by Reginald Braithwaite. I'm scarcely
exaggerating when I say the book completely changed the way I look at
JavaScript.

~~~
the_mitsuhiko
I don't know a single language where the standard map function passes two
arguments instead of one. Python has the starmap function as an alternative in
case someone really needs that.

~~~
actsasbuffoon
I agree that it's probably a bit unusual, and likely owes to the fact that all
JS functions are variadic and ignore arity mismatches. Ruby's procs behave the
same way, though its methods and lambdas are more traditional.

------
cpeterso
The typeahead.js library should use a binary search of a sorted string array.
A trie of string prefixes would be more elegant, but it would probably have
worse data locality and heap fragmentation.

And instead of searching the entire database for every new prefix (e.g. "s",
"sa", "san", "san f"), the API could return a stateful query object that could
be more efficiently refined.

------
elwell
Linked [0] "Time Scheduler" is pretty cool but it crashed twice on Chrome, and
also the time brackets can't be dragged. I had an idea a couple days ago for
this exact 'app'; if it was a little more accessible/reliable, I might
actually use it.

[0] - [http://timesched.pocoo.org/](http://timesched.pocoo.org/)

~~~
the_mitsuhiko
It was quite literally a weekend project and I did not want to waste much time
making custom controls. The sliders are jQuery's UI sliders and as such not
particularly well suited for what this should do. Might spend some time
replacing this with something better.

As of why it would fully crash chrome I'm not sure. Maybe it runs out of
memory? I think it wants about 80MB with DOM and everything and builds that
out of 3MB of payload (which is about 20MB more than the google search page).

//EDIT: code is also on github under a BSD license in case someone wants to
work on it:
[https://github.com/mitsuhiko/timesched](https://github.com/mitsuhiko/timesched)

------
ommunist
Good article. And I admire your cute and clever selection of fonts. No,
seriously.

~~~
elwell
What a very cute and clever thing to say.

------
xiaoma
> _" For this project I obviously used jQuery which is impossible to avoid
> (and why would you) but also AngularJS with a bunch of UI components
> (angular-ui and some bindings to jQuery UI)"_

Lol. Is this author trolling us? I don't know anybody at Google who uses
jQuery, and Angular makes it particularly easy to avoid.

Cute and clever indeed!

