4 ms·
I assume everyone who splits code into smaller pieces use modern IDEs that makes it trivial to navigate to functions by clicking them etc. I say this because I
by BurningFrog 8y ago
I assume everyone who splits code into smaller pieces use modern IDEs that makes it trivial to navigate to functions by clicking them etc.
I say this because I'm always astonished by the number of "modern" programmers who refuse to use IDEs.
- m_mueller 8y agoIDE or not, jumping around between functions amd their callers to understand a process is annoying.
- BurningFrog 8y agoSure. In sane code the name of the function should describe what they do well enough that you rarely have to click in to learn how they do it. Or something like that...
- TeMPOraL 8y agoThat applies recursively to the function you're just reading :). I.e. I wouldn't be inside a particular function of a particular module if I didn't have to know something about its implementation. There's a good chance I need to understand all of it at the level of abstraction of the module (often because I'm supposed to change something about it). Making that less painful leads to better and less bug-inducing experience. Elsewhere[0], 'usrusr brings attention to nested functions, lack of which I see as a huge factor contributing to overeager splitting of code. With nested functions, you can have "best of both worlds" - a function whose implementation is divvied up into well-named pieces, while keeping those same pieces in the correct conceptual place, close to where they're used, and restricted from polluting unrelated code. -- [0] - https://news.ycombinator.com/item?id=18773691 https://news.ycombinator.com/item?id=18773691
- m_mueller 8y agoTotally agree on nested functions. I currently have to deal with Java, and those are the biggest thing I miss from Python.
- cmsj 8y agoI would make no claims to being an exceptional programmer, but fwiw I don't like nested functions - it always takes me a lot longer to reason about what a function is doing, when it has functions defined inside it.
- barrkel 8y agoThis can depend on the syntax and semantics of nested functions. Pascal nested procedures are pretty easy to parse and if they're defined before the `var` block then you don't need to worry about non-local state modification (apart from the parameters, but modifying parameters is unusual). First-class nested functions with variable capture are harder to understand. Nested functions in e.g. JS are more like object construction than function definition, and it's generally expected that such nested functions will be capturing state from the enclosing context. Standard Pascal permitted outer scope variable access combined with downward funargs - the nested functions could be passed to other functions, but could not be stored in variables or returned as arguments. This reduces the non-local effects, and handily doesn't require a GC to ensure memory safety, since the captured state can stay on the stack, because the nested function won't outlive the frame. For nested decomposition of a problem, I'm more of a fan of Pascal-style nested procedures than nested function expressions like in JS. Idiomatically, one expects function expressions to capture state, while nested procedures are just more procedural decomposition.
- m_mueller 8y agoI second the answer about having them before var-block: In python I always follow the style of having nested functions directly after the outer function header, and only going one layer deep. This way the only thing in their scope is their parameters as well as the parameters of the outer function. Using this restriction I find them very useful and concise - much better than having one-off helper functions in the outer module scope.
- BurningFrog 8y agoYou seem to be arguing against the concept of functions in general here. That's probably not what you mean to say, but I don't find much to really discuss here. I do like local functions in Python, but I don't see a huge difference from having the called function right below the calling one.
- szemet 8y agoI have read an extreme counter-opinion in some J or APL article. It said that it is a bad pactice to name small and common functions: The example was maybe the average function - and the reasoning was, if I recall correctly: 1. The defintion is shorter then the name average ;) 2. Every praticioning programmer will recognise the definition as a common idiom 3. From the definition it is immediately clear how corner cases are handled (e.g. zero length array) I just leave this here as an example to show, that programming communities/cultures exists with completely different/alien? ideas about what clean code is ;)
- AstralStorm 8y agoAllegedly. And then you suddenly want to write a SIMD version of an average or optimize it... Mass search and replace time? That'd bloat the code a lot. Common repeated well defined and mostly immutable code is best left as functions. This is why for example in C strcmp exists instead of everyone writing a two-liner - and the specialized variant gives big performance gains.
- szemet 8y agoI've got your point. Just for the sake of nitpicking: both your actual examples have been solved by compilers automatically. SIMD/AVX: https://code.jsoftware.com/wiki/Guides/AVX https://code.jsoftware.com/wiki/Guides/AVX JVM generates vectorized string instructions from your simple for cycles - if availabe: http://jcdav.is/2016/09/01/How-the-JVM-compares-your-strings/ http://jcdav.is/2016/09/01/How-the-JVM-compares-your-strings... edit: my second example link is maybe wrong, but anyway, auto-vectorization is a real thing...
- TeMPOraL 8y ago> I assume everyone who splits code into smaller pieces use modern IDEs that makes it trivial to navigate to functions by clicking them etc. That's... not the point. Jumping around is. Imagine reading this comment thread on a bizarro-HN, where you only get to see a short camelCased summary like: debunk(this.previousComment), and have to click to open each comment in a new tab. This is how jumping around small functions feel. > I say this because I'm always astonished by the number of "modern" programmers who refuse to use IDEs. There are reasons for it. Many languages don't have an IDE. Many are not suitable for one (especially ones closer to Lisp on expressiveness spectrum). IDEs are heavy and often mouse-oriented, and not efficient for reading and editing text. Sometimes (read: Java) they are a crutch to work around the expressive deficiencies of the language. Mind you, I have nothing but good things to say about IntelliJ. I've spent a lot of time in it even recently, and I pick it up any time I have to do anything in Java. But for everything else, I launch Emacs, because it can handle all other languages well, and has superior editing capabilities.
- jonahx 8y ago> That's... not the point. Jumping around is. There is a tradeoff: Small functions make high-level logic clearly visible and easy to find, at the price of forcing you to jump around when you want to dive into implementation details. Putting everything into one big function lets you follow all the implementation details without jumping, at the price of making you read everything to actually understand what the code is doing. The latter is the biggest price you can possibly make me pay. Jumping around is a minor inconvenience.
- bitexploder 8y agoWasn’t that the purpose of the long comments: To sketch out the high level logic, while keeping all the code in one place. Jumping around, you now have to do that to be sure of the details and the complexity can be hidden in layers of functions. Complexity that often matters.
- spockz 8y agoBy choosing the right names for a function or class a lot of jumping around can be prevented. Most IDEs also have a feature (including key combination) to show the documentation of the method/function. The only reason that remains is when you doubt the correctness of the method and need to look at its definition.
- lliamander 8y agoFor Java programming, I definitely use IDE. Even for Erlang programming I use Emacs with EDTS to get a more or less IDE experience. I'm saying that, even with that convenience, I don't wrapping a line or two in it's own function is more readable than just adding a comment above those two lines within the context of a (somewhat) larger function.