cbeust

dlsspy:

It depends. I make complex merges/branches on a regular basis and I find myself using `commit -a` pretty often, but I am also diligently branching out whenever I start working on something different, so I'm often confident that all the files that are both tracked and modified are the ones I want to commit.

blasedl:

I think that `git add -p` (committing certain changes in a file but not others) is a pretty advanced feature. I can see how it can be a life saver for experienced users, but I recommend creating two branches with each 100% of your changes rather than using just one branch that contains 60% and 40% of your changes.

One switch that I find very useful is `git add -i`, which you should use whenever you want to add 2 files but you have 20 untracked ones in your working directory.

I wrote the Translate application for Android and I've had numerous people telling me in comments that thanks to my app, they were able to hook up with foreign girls and get laid.

My thought when I got the first comment of this kind was "jwz would be so proud".

Definitely: radio is the killer app that will save Nokia.

Actually, the book "Design and Evolution of C++" shows Stroustrup saying "no" to quite a few features (e.g. named parameters). It would probably be more proper to say that Stroustrup didn't say "no" to enough people.

You need to make languages fast on both dimensions, static and dynamic. A dynamically typed language can only be optimized in one dimension, which is why they usually trail behind statically typed languages in performances (since those are optimized along both axes).

I sympathize with the author's dislike for C++ and while you can't argue that dynamic languages "could" at some point in the future be faster than C++, it's very unlikely to happen since one of the requirements for this kind of speed is for a language to be statically typed. Without type information, the compiler is left with very few options to optimize the generated code.

As was pointed above, I'm not opposed to fluent interfaces and we use quite a few at my work (Google).

I was just observing that you can't argue against mutators and then encourage people to use fluent interfaces since they are basically the same thing.

> Because of this, I'm tending to believe that > adding more strong-typing to languages is a > losing battle,

I see this at the opposite.

Just because an object says that it responds to a method doesn't guarantee that invoking said method will succeed. I'm not sure why the original poster is so surprised by this finding.

Since this observation is valid in both statically and dynamically typed languages, I prefer a statically typed one since at least, I don't need to verify that the object does respond to that method before calling it.