What kind of query optimization can it for scanning data that’s already in memory?
What kind of query optimization can it for scanning data that’s already in memory?
No so much that YAGNI falls short, but more like “When YAGNI means ‘You Are Gonna Need It’”
absolute beginner? Start at https://www.hedycode.com/
Which will ultimately lead into vanilla Python. This is the creator explaining why Hedy is uniquely designed for learning: https://www.youtube.com/watch?v=fmF7HpU_-9k
I’ve never seen these “express code/tests in natural language” ever work well. Your non-coders need lawyer-like skills to wield English very precisely, or it falls to coders that would be better off using code directly.
problems only have one answer and often one strategy to get to the answer
Totally disagree
You’re thinking of equations, which only have one answer. There are often many possible ways to solve and tackle problems.
If you’ll permit an analogy, even though there’s “only one way” to use a hammer and nail, the overall problem of joining wood can be solved in a variety of ways.
IMO mathematical/logical/abstract thinking is critical for programming well, but IMO that’s different from “math degree” math.
Software as a means to an end can be used in almost every domain, so proficiency within that applicable domain is often either useful or necessary. That is to say, “math degree” math is likely needed for 3d rendering (certain games), scientific computation (incl machine learning), etc, but maybe not, otherwise. It depends on what software you’re trying to build.
To be more specific, general programming is definitely and specifically different from trig and calc. However, because math is also broad, “mathy” concepts like type theory, relational algebra, set theory are considered important for programming, even if only informally or indirectly so.
I don’t understand, if you’ve got easy to delete copy-pasted code, then delete it. It’ll be a nice and cathartic exercise.
But sounds like what you’re really talking about is code that isn’t easy to delete.
IMO folding to hide is about equivalent to moving all contents to another file/private function:
def bad_function(args):
return _hide_elsewhere(args)
i.e. does nothing. Real solution to pyramids of doom is to fix the code.
That’s changing the goal posts to “not static”
Sounds easy to simplify:
Use one of: constructor A(d)
, function a(d)
, or method d.a()
to construct A’s.
B and C never change, so I invoke YAGNI and hardcode them in this one and only place, abstracting them away entirely.
No factories, no dependency injection frameworks.
IMO factory functions are totally fine – I hesitate to even give them a special name b/c functions that can return an object are not special.
However I think good use cases for Factory classes (and long-lived stateful instances of) are scarce, often being better served using other constructs.
Dedicated incremental static type checkers for dynamic languages already exist. In particular, Pyright for Python is fantastic and in many ways surpasses the type systems of classic typed languages
But would you pay for it?
My employer’s paying for my access, and I only find it a bit useful here and there
Maybe my company gets a great discount or something, but if they would pay me the subscription cost to give up Copilot, I wouldn’t miss it
One of the best tutorials on really “grokking” git
concepts, and it’s online and interactive: https://learngitbranching.js.org
For programming, start with buildings things for yourself. Be practical, start small, and iterate, regardless if you consider the previous iteration was a success or failure. I’ve heard good things about https://automatetheboringstuff.com/ (in Python) in this regard.
Can address it by writing code that doesn’t depend much on indentation, which also makes code more linear and easier to follow.
All methods? Of course not. Just methods like these.
I really dislike code like that. Code like that tends to lie about what it says it does and have non-explicit interactions/dependencies.
The only thing I can really be certain from that is:
doAnything();
if(doAnything2()) {
doAnything3();
}
I.e. almost nothing at all because the abstractions aren’t useful.
I agree with the author overall, and I think it can be more straightforwardly stated. IMO it’s the idea that wrong abstractions are even worse than other ills like duplication or god classes/modules. It’s also reminiscent of “modules should be deep”.
The synchronization problem (flakiness and all the waits) is tricky to get right. Browsers are concurrent systems, and programming around one is specialized enough that many devs don’t do it well, e.g. IMO if you’re adding ad-hoc waits or nesting timeouts, you’ve already lost.
Hm, that’s kind of interesting
But my first reaction is that optimizations only at the “Python processing level” are going to be pretty limited since it’s not going to have metadata/statistics, and it’d depend heavily on the source data layout, e.g. CSV vs parquet