The left-to-right evaluation order of the iterables is guaranteed. This makes
possible an idiom for clustering a data series into n-length groups using
zip(*[iter(s)]*n).
http://docs.python.org/2/library/functions.html#zip The left-to-right evaluation order of the iterables is guaranteed. This makes
possible an idiom for clustering a data series into n-length groups using
zip(*[iter(s)]*n).
http://docs.python.org/2/library/functions.html#zipReading this post brought back that feeling.
If people don't understand a completely valid and terse way of coding something, sometimes instead of bothering to understand it, they will bash it. Sometimes, this is a totally valid way to vent frustration, and then they learn something new, and all is good. But sometimes, it just gets left as "this is wrong" and then someone else thinks it is wrong, and so on. That is wrong, and tech leads or architects that enforce such crap will bug the living shit out of good developers and lose them.
I appreciate clarity. But, terse one-liners can be just as clear if not clearer than code that unnecessarily adds more methods/functions/names/local vars and claims to be "more testable", etc.
You shouldn't have to sacrifice the ability to be terse and clear at the same time. Testing is no excuse for code bloat. You can likely write a test that executes the behavior without having to atomize it. Assess the amount of production and test code you are writing. How much more code are you actually having to write in order to test, both in the tests themselves and in the code which you are having to test?
It happened here with Python and it happens in many languages. It even happens with laws and regulations in government. If someone gets the same thing done just as ethically but without the bureaucracy, just appreciate it as another perhaps better way of doing something. Don't bash it publically because you don't understand it.
w/r to Python in particular, it has a history of ending up with idioms that are "tricky" and not particularly more or less terse than other techniques, but are able to exploit the standard library functions to get a faster-running result.
This is, of course, at odds with the motto of "there should be only one (obvious) way to do it," so every experienced Python programmer has to internalize a small dictionary of idiomatic one-liners for these exceptional cases. (Fortunately, it's not that big. I can only think of three or four off the top of my head.)
Errors per LOC is allegedly constant, across all languages.
I also consider the cost of change when designing things.
I once created an HL7 wrapper that was a marvelous thing of beauty. Fluent API, clever use of the type system. But no one could maintain it, including me. It had too much magic. So I scrapped it, went with a dumber implementation.
If this is true, then a more verbose style will have a higher error rate. (more LOC to do the same task -> more errors)
This implies that more expressive languages(more expressions per line) are less prone to errors.
You conclusion would be correct if he had stated that error per expression was constant between languages.
I think that's what he means.
Well, there is some truth to that. Anecdotally, most lines of code will be read many times before they are changed/discarded, and most of this reading will be skimming, where the reader is either: 1) trying to understand the structure of the code, or 2) trying to figure out where to make modifications.
Code that's hard to understand quickly (e.g. by skimming) is technical debt. I think a good litmus test would include not just the effect on error rate, but also the effect on the time it takes to understand the code and to make changes to it.
I write specialist-o-matic code. Lotsa DRY, composition, iterators, "fluent" APIs.
Makes me an unapologetically poor general purpose pair programming partner.
terse and clear at the same time
Concision is a virtue.
Can be.
Or do you mean there's some value in redundancy? I'd be interested in an example. Even java added the <> to avoid the repeated template parameter,
Foo<Things> x = new Foo<Things>();
becomes Foo<Things> x = new Foo<>(); val x = new Foo<Things>();At least, that is my experience in the world of web-based programming. Scripts and other single-purpose code implementations are another case entirely.
(echo -e "one\ntwo\nthree\nfour") | paste -d, - -
to get result of: one,two
three,four
by exploiting a similar trick, i.e. reading two times ('- -') from the same iterator (STDIN of 'paste') $ seq 1 9 | paste - - -
1 2 3
4 5 6
7 8 9 echo -e "one\ntwo\nthree\nfour" | paste -d, - -
works just fineI've updated the post with this, another commenter pointed it out. Thanks!
This is one of those cases where Ruby does it better (s.each_slice(3).to_a).