4 ms·
How is writing code that loops over a list simpler than calling: things.Get("key") ?
by smegel 9y ago
How is writing code that loops over a list simpler than calling:
things.Get("key")
?
- khedoros1 9y agoYour "Get" method hides complexity. It could be that it loops over a list, or that it hashes to find the bin, then loops over the list of items in the bin, or any of other dozens of other possible implementations. So the next question is "What's the implementation of the Get(key) method?" Or maybe "Why aren't you using your language's library methods to loop over that list?"
- smegel 9y agoWhy are you even asking the question if profiling hasn't determined a performance problem in that bit of code?
- khedoros1 9y agoI'm considering cases where looping over a list mean using a simpler algorithm than whatever's provided by "Get", applying rules #3+#4, after determining that "Get" is a bottleneck.
- deleted 9y ago[deleted]
- parenthephobia 9y agoIs this really an explanation of why manually iterating over a list is simpler than just calling a method? Get is simpler precisely because it hides the complexity. > Or maybe "Why aren't you using your language's library methods to loop over that list?" What makes those methods not subject to the "hiding complexity" objection?
- khedoros1 9y agoIt's an ill-considered stream of consciousness where I wasn't clearly separating "simplicity of interface" from "simplicity of implementation". Part of what I was going for is that a clean interface might hide a complex implementation. If you've followed rule 1 and see that "Get" is a bottleneck, it makes sense to apply rules 3+4, and see if there isn't a simpler implementation than the one provided by "Get".
- winterlight 9y agoThe interface is the same. For example, in C# you have an interface Collection, which offers a lookup method, and which both HashSet and Lists implement. The point of the OP is that among different implementations for the same interface, choose the simplest one unless you have empirical evidence that compels you to do otherwise.
- seanmcdirmid 9y agoArrays didn't implement interfaces in C# until the Linq release. But the main problem is that arrays have an interface st is much more complex than just ICollection, they have functionality you don't want to be used and that should be properly encapsulated.
- smegel 9y ago> which offers a lookup method, and which both HashSet and Lists implement How does a List map values to key? How does it even represent them?
- winterlight 9y agoThe lookup method just checks whether an element exists in a collection or not. List and HashSet implement non-indexable collections, which have no notion of key. The Collection interface is very thin, and it's mostly used when you need to keep track of a set of elements. E.g. storing the nodes already visited in a dfs.
- smegel 9y agoOK I know more about C# now than I ever planned on knowing. The problem with OP comment is that KISS and premature optimization are not diametrically opposed. Thet are two separate principles that mean different things. Premature optimization is bad, but not because it necessarily violates KISS. Similarly, many people overcomplicate code for reasons nothing to do with optimization. His argument reminds me of people who argue against free speech generally because we already ban people shouting fire in a cinema.
- 9y ago
- rdiddly 9y agoIn terms of programmer time/effort, using .Get() is simpler. In terms of program speed/optimization, the answer depends on how .Get() is implemented.
- smegel 9y agoWriting simple programs that meets requirements should be your goal. Premature optimization is the root of all evil.
- rdiddly 9y agoSimplicity is great when it's not borne of ignorance and when it doesn't over-simplify. Some things are unavoidably complex. Even the word "simple" is complex, and has many meanings. What if simple is defined as... - relies on simple "Programming 101" concepts - doesn't require using or learning a framework or library - corollary to above, doesn't require ascertaining that said framework or library implements a .Get() method - doesn't rely on anyone else's code and has no dependencies or references - doesn't require understanding ancillary concepts that might be present such as hash tables Then writing the loop is "simpler." To answer your original question. And just to turn things completely topsy-turvy, how about your .Get() method. If it's implemented the way such things are usually implemented, that means it uses hash tables and is very efficient. But that means it's a premature optimization, right, and therefore the devil? (Well we haven't defined "premature" either.) The real answer is to think for yourself like a grown-up and don't rely on dogma. Every situation is different; tackle every problem by optimizing for what's important in that specific problem, using whatever resources and minding whatever constraints apply to that specific problem.
- djur 9y agoSelecting appropriate data structures and algorithms for a problem is not optimization. It's one of the basic skills and responsibilities of a programmer. That's why the bulk of the first volume of Knuth's _The Art of Computer Programming_ is about data structures.
- 9y ago
- coldtea 9y agoWho said you get to use a ready-made Get method / hash?