[wellpast]

> I also count lines when choosing libraries. When you depend on a library, the library code becomes your code in a way. [...] If two libraries do roughly the same thing, but one has far fewer lines, I will usually prefer the smaller library.

This is a little odd imo. Far more important when choosing a library are other aspects like its maturity, activity, interface width...

In fact, the goal in choosing a library should be to minimize the probability that the "code becomes yours." You should be looking for a strong and stable abstraction, first and foremost.

[adambard]

I think this heuristic is using lines-of-code as a proxy for simplicity, in the simple-vs-easy sense. All other things being equal, and presuming the difference is architectural rather than an artifact of a too-clever coding style, I would tend towards the shorter library too.

[wellpast]

Fair enough. In my experience it is rare to need library X and to have such an array of choices that LOC suddenly becomes the differentiator.

[adambard]

I've never turned to LOC directly myself, but I have occasionally had to choose between 2 or 3 lone-wolf Clojure libraries to do a thing, and picked the one that seemed to have the sharpest focus or the most coherent implementation, which is usually the shorter one.

[shadowmint]

> All other things being equal...

...but they're not. Perhaps one time in 50 you'll find a topic so well worn that you have choices between multiple mature, stable libraries with good APIs that lets you dig into the source code to see how nice it is (by whatever metric) to decide if you want to use it.

Perhaps what, json parsers?

I can barely think of any other examples.

It's a completely pointless metric.

The beauty of the API is far more important than looking into the implementation to see how it was written.

Heck, the library could be one giant regex on one line, but if the api is:

    void *libfoo_random_meaningless_name(void *n, ...);

...there's no way you'd want to touch that library.

I very much doubt the elegance of the implementation is a metric that should be used to pick a library; there are far more important metrics to look at.

[aaroniba]

I agree there are many considerations when choosing a library, but conciseness does come up. For example, I was recently impressed with how concise http-kit is. The author seems proud of it too:

http://www.http-kit.org/http-kit-clean-small.html

You and I probably just have different values on this matter. Your comment implies that conciseness is merely "nice", so I'm guessing you just don't value that aspect of code as highly as I do.

[shadowmint]

We'll have to just disagree.

I place zero value on the detail of the implementation of a library; only on the API that I use.

It's like picking a radio at the shop by opening each of them up and inspecting the quality of soldering and board schematics.

...yes, you'll get a better radio if you do, but if you're furnishing a kitchen, you'll spend the rest of the month opening appliances and looking inside them instead of building your kitchen.

I guess it depends what you're doing.

/shrug

[aaroniba]

Yes. You put it better than I did.