elbenshira

> Let’s be clear about what this means: it gives them access to the corporate bond market. What they’re lobbying for is that pension funds, life insurance, etc., can take exposure to these companies. Suddenly the everyman, your mom and dad, have significant exposure to these companies and their circular financing deals without even knowing it. This is disgusting.

What's the problem? Fund managers—who are in a position to understand the risks more than your everyday investor—can decide if they want buy these bonds or not, just like any other public corporate bond.

For some reason I was thinking about Bob two days ago, ten years since I last interacted with him. I was just an intern at Square and he had just joined as CTO. But I remember how patient and inquisitive he was with me. Rest in peace, Bob.

In this case, you think of `connectWords` as a function that takes two arguments. But since it is curried, you can also do this:

    let prefix = connectWords "Hello "
        world  = prefix "world"
        bob    = prefix "bob"
    in ...

`world` is "Hello world", and `bob` is "Hello bob". That is the power of currying. A maybe more useful example is specifying the mapping function in `List.map` without supplying the list to map over. This allows you to use the same map with multiple lists.

In the article, I mention that linters for dynamic langs are crippled. Of course I use them when writing Ruby. But can any of these tools tell me:

  - When two equivalent anonymous functions can be extracted out?
  - When a library method already exists for an expression?
  - When you fail to match every possible result in a case statement?

Yes, I may have failed in getting it across, but a big point is this: I don't think dynamic languages will suddenly die out. Instead, strongly-typed languages will become more convincing. We are seeing better tools, and they are becoming more ergonomic.

Elm's latest blog post said it really well:

> Compilers should be assistants, not adversaries. A compiler should not just detect bugs, it should then help you understand why there is a bug.

http://elm-lang.org/blog/compilers-as-assistants

A note on Typed Clojure: Ambrose is doing excellent work with it, and I'm excited to see it develop.

But I wished there was a bigger push from the top, from Rich himself, on "first-classing" typed Clojure. Aim for 100% annotation coverage for the most popular libraries. Start with core (maybe it already is? I haven't kept up) and ring, then move outwards from there.

Library writers will be more motivated to add annotations if the big libraries are doing it.

Yes, I did miss the ring spec. But as a beginner to ring, I'm not sure how I was suppose to know that such a document exist.

For the most part, Ring is well-documented. But, as you noted, human-typed doc strings go only so far. I applaud the writers of ring in their discipline, but certainly we can do better than depending on human discipline.

You even noted, I picked "less well-documented libraries." I didn't pick them because they were not well-documented—I picked them because I'm using them!

Yes, read this part: https://github.com/Gabriel439/post-rfc/blob/master/sotu.md#t... and https://github.com/Gabriel439/post-rfc/blob/master/sotu.md#r...

From my (short) time with Haskell, I've found the type system to be the best I've ever used. It really does feel like it's helping you, instead of getting in the way. And so it feels more like a dynamic language than other strongly typed languages I've used (e.g. Scala, Java).

Below is a simple example, but look, no types to type!

    >> let plus1 = (+1)
    >> plus1 10
    11
    >> :t plus1
    plus1 :: Num a => a -> a

You can ask for the type by `:t plus1`.

I've also used Clojure, and I do really like Lisps, but I don't think untyped languages give enough benefit for all the problems it causes. I'm excited, however, about Typed Clojure (and Typed Racket).

If I understand correctly, the ClojureScript compiler was written in Clojure (that is, you had to run the JVM to run the compiler), which spat out JS code and then compiled by Google Closure.

Would you be able to explain, at a high level, how ClojureScript bootstrapped itself, and how Google Closure comes into play?

This is an acceptable description.

I missed an opportunity here.

Because these universities produce more students than tenure-track positions?

A "map" is a graph.

That article was what inspired me to write this blog post.

In short, the key insight of the blog post is this (via untested javascript):

You can define transforming functions like map and filter via reduce (e.g. foldleft or, for Ruby, inject) instead. For example,

  map([...], function (x) { return x + 1; });

Can be written as:

  // append (x + 1) to the result collection
  reduce([...], [], function (result, x) { return append(result, plusOne(x)); });

But notice that, above, we explicitly chose `plusOne` and `append`. If we allow a user to pass in any function instead, then we have a higher-order function:

  function mapping(f) {
    return function (reducing) {
      return function (result, input) {
        return reducing(result, f(input));
      }
    };
  }

Now we can do:

  var xform = mapping(plusOne)(append);
  
  reduce([...], [], xform);

`xform` is a transducer.

Lots of research has gone into this, under the name Byzantine fault tolerance.

http://en.wikipedia.org/wiki/Byzantine_fault_tolerance

Why not just use:

https://lastpass.com/

https://agilebits.com/onepassword

http://keepass.info/

Classic: http://www.slideshare.net/guestbe92f4/how-to-design-a-good-a...

RESTful Web APIs (http://shop.oreilly.com/product/0636920028468.do) was a good starting point for understanding RESTful HTTP APIs.

Don't immutable data structures give us most of the benefits? Clojure, for example, approaches this by preferring values over hidden, mutable state (e.g. classes). We see libraries like Om take advantage of the fact that comparing two complex structures (e.g. a hash map) is simply a reference equality test.

http://clojure.org/state

http://swannodette.github.io/2013/12/17/the-future-of-javasc...

I'm a premium Evernote member, but I've also had lots of problems.

The iOS app is slow and clunky. I hate using it. It crashes all the time, especially when I'm trying to take snapshots of a document with many pages (and all previous snapshots simply disappear).

The desktop app is better, but they really could improve the writing experience. Pasting HTML blobs is impossible, and so is formatting my notes the way I want (I use TextExpander for sanity).

Evernote is great when it works, but they really need to fix their stability and bug problems.

I remember an article about how Gowalla was bringing SV talent to Austin. Heh.

I'm confused too. I read everything on their website and I think I get it but I don't. I remember it used to be that you had to be within the proximity of the business to use the money, but now they're all "it's flexible!".

Why shouldn't they? With TDD and pairing, I'd say that their developers are the QA team.

Alan writes useful things, but this is pretty much meaningless. He says so himself: "Developer are programmers to a greater or lesser extent. Computer scientists are programmers to a greater or lesser extent."

Why put ourselves into different camps? Why can't I write poetical Rails code during the day and read the latest research papers on type theory at night? Placing ourselves in these artificial camps hinders us from exploring new places and ideas. This is why I'm tempted to call myself an artist or inventor (though to much ridicule) instead of a programmer or developer or computer scientist.

I wonder how Hacker Monthly (http://hackermonthly.com/) will pick out the "best" comments.

Maybe I'm really lucky, but I'm still in school and I've worked for several startups. Being in a start-up city (Austin) definitely helps. And I would go to tech events and ask if anyone is looking for an intern. That's probably the best (i.e. easiest) way. And know the technologies they use (hardly any students know rails), because startups don't have time to train you.

I'm studying at UT Austin, and I love all the theory work. It's challenging and makes my brain hurts, but the insights you get out of all this work changes the way you see programming and software engineering. You start yearning for beauty and elegancy, much like the algorithms we study. You find that you start thinking like a theorist in your every-day coding: what am I trying to solve? What are the constraints? How do all the pieces work together? Do I need this piece over here?

Some theory may not be practical, but learning to think the way theorists think is very, very practical. And a lot of fun.

My story: After my technical phone interviews, I got "accepted" as an intern, meaning I was in the Intern Pool of Rot, where I waded and waited for a team to fish me out. I waded and waded for a couple of months, hoping for a kind suitor. The HR woman always told me that she was "optimistic" about my prospects, so I rejected offers from other companies.

Then a really cool opportunity came, and I accepted that offer because you can't just sit in a rotting pool for two months.

A friend of mine stayed in the rotting pool and was told at the beginning of summer that no one at Google wanted him.

This was 2009-2010. I hope Google changed their ways.

I think the original paper is very readable: ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf

We used this at UT Austin, and it's a great book. It doesn't have a lot of stuff that you would find in a graduate PL course (e.g. type theory), so it doesn't prepare you to read PL papers, but building a lisp in scheme is a lot more fun than learning type theory!

And probably more useful, as the author asserts in his paper.

RethinkDB is not a webapp.