But IMO that’s one reason weird UX/design is not uncommon and can persist in dev ecosystems. The intended users are more proficient than average and most are able to work around most issues.

If the goal is evaporative distillation, it makes no sense to use a process that begins with filling and conaminating the entire system with contaminated water

You’d have more success keeping the container clean (full of air) and pumping all the air out of it, which is still probably less efficient than other means like boiling

It’s a container with certain behaviors and guarantees making them easy and reliable to manipulate and compose. A practical example is a generic List, that behaves like:

• List[1, 2, 3], i.e. (“new”, “unit”, “wrap”) to create, containing obj(s)
• map(func) to transform objs inside, List[A] -> List[B]
• first(), i.e. (“unwrap”, “value”) to get back the obj
• flat_map(func), i.e. (“bind”) to un-nest one level when func(a) itself produces another List, e.g. [3, 4].flat_map(get_divisors) == flatten_once([[1, 3], [1, 2, 4]]) == [1, 3, 1, 2, 4]

Consider the code to do these things using for loops – the “business logic” func() would be embedded and interlaced with flow control.

The same is true of Maybe, a monad to represent something or nothing, i.e. a “list” of at most one, i.e. a way to avoid “null”.

Consider how quickly things get messy when there are multiple functions and multiple edge cases like empty lists or "null"s to deal with. In those cases, monads like List and Maybe really help clean things up.

IMO the composability really can’t be understated. “Composing” ten for loops via interlacing and if checks and nesting sounds like a nightmare, whereas a few LazyList and Maybe monads will be much cleaner.

Also, the distinction monads make with what’s “inside” and what’s “outside” make it useful to represent and compartmentalize scope and lifetimes, which makes it useful for monads like IO and Async.

Python deps can be dynamic, so it can be necessary to download the package and execute code just to find out.

Would be nice to see a resource that lists out the statically defined ones, though. Perhaps that’d pressure the dynamic ones to change – it’s a cause for some of the notorious pain of Python packaging.

IMO it will “succeed” in the early phase. Pre-seed startups will be able demo and get investors more easily, which I hear is already happening.

However, it’s not sustainable, and either somebody figures out a practical transition/rewrite strategy as they try to go to market, or the startup dies while trying to scale up.

We’ll see a lower success rate from these companies, in a bit of an I-told-you-so-moment, which reduces over-investment in the practice. Under a new equilibrium, vibe coding remains useful for super early demos, hackathons, and throwaway explorations, and people learn to do the transition/rewrite either earlier or not at all for core systems, depending on the resources founders have available at such an early stage.

Highly recommend having some scripting/interpreted language in your stack – in fact you likely already do (consider how shell scripting makes up a significant part of Dockerfiles)

It’s an incredibly useful intermediate between freeform-but-non-executable text/docs/wikis and “industrial-grade”-but-inflexible tooling

In other words, a great fit for capturing this partial/incomplete/tribal knowledge space the post is talking about. I personally even go a bit further and actively advocate for converting “onboarding/operational docs” from wikis into scripts that print out the equivalent text that can be committed and incrementally automated.

In my experience, LLMs aren’t really that good at summarizing

It’s more like they can “rewrite more concisely” which is a bit different

https://f-droid.org/packages/de.t_dankworth.secscanqr/

If you want to entertain having kids, you need to be ready for a radical shift in your life priorities. Your kids will take priority over just about everything – often even yourself. They’ll take priority over your parents entirely, let alone your personal relationship with them.

First, are the practical and logistical aspects of your life at all dependent on your parents? I.e. are you fully independent? You will need to be and then some, you’re going to entertain having kids.

Once you’re fully independent and additionally have resources to spare (time, effort, money, space, etc, usually b/c you’re with a partner you can trust and rely on), then choosing to have kids means starting your own family – not your parents’ family.

If the grandparents are supportive and helpful, that’s great! They’re extremely welcome to contribute to your kids’ lives (and lighten some of your parenting load!)

However, if they’re negatively impacting you or esp your kids, then they can lose that privilege. Again, your priority will be your kids. If this is a real concern for you, you’ll need to factor it into your “ready to have a kid” considerations.

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

What’s hard about vanilla Ruby?

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’”

Can that barrel hold fluids? B/c then what about the ocean or even the atmosphere? (Though it would take a while)

Could’ve held one rod end in each hand, letting middle of rope ladder hang down for standing on, like stirrups

Alternate left/right and you can step in any direction into the air

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.

It’s the difference between knowing you’ll grow and graduate together with your classmates vs knowing you’re only going to see them for that one month before you move away.