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.
First suggestion is impractical. Not going to be able to memorize 100 names to look up and research later
Second suggestion should already be happening, but doesn’t capture the desired use case.
The use case is this: in physical life, there is a gradient of “boundaries/leashes” to match maturity and development. For example, the gradient of movie ratings, or:
We could argue about whether a gradient is too steep or shallow, but the point is that one exists.
In contrast, digital in many ways is very often all-or-nothing
Not saying digital should be “gradient-ed” in all cases, that leads to tone-deaf rules and bad security practices. Just trying to show what the problem is
I think there is a difference. Because software is so flexible and quick to build, it’s orders of magnitude easier to build something known and understood.
A promising startup with its systems in a knot, but their initial team is still on retainer? Brains can be picked, abstraction boundaries placed, surgical rewrites deployed. Despite the mess, they still understand it, and development can expand.
It remains to be seen if AI-generated code is recoverable, if any existing strategies can be applied so humans can contribute, or if the company is forever beholden to AI providers to release a better AI to manage/improve what they’ve already got.
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
Thinking about that quote, it sounds nonsensical
At the outset, all businesses seek to grow faster than the average/stock market. Five years later, half will do better than average, and half will do worse than average.
Saying that the half that did worse should have instead invested into the market, five years ago, is kind of meaningless.
Yes, I’ve seen a video file that changes resolution mid-video, but it’s more of a party trick since not all players handled it well
Specifically, I saw a group chat program rendered it “correctly” (Discord? I don’t remember), so the embedded video would re-flow the rendered chatroom while playing
Also have the option of selectively/strictly enforcing in CI, to get an experience & protections similar to “compile-time type checking”
it lacks clear and enforced type restrictions which help with clear code contracts
Not anymore! Gradual typing is supported by the core language and pyright is a fantastic incremental type checker that you can use both in your editor and in CI.
I think your ideas are too non-practical/specialized/advanced/low-level for your stated goal of 'digital literacy". They read more like college intro/followup course material and are too esoteric to be readily absorbed, esp by generic teenagers, even if they’ve self-selected to be “lightly interested”.
If it takes 1+ hours of work to remove a feature flag branch in an area of code, I wouldn’t trust the correctness of anything the AI writes and would be super skeptical about anything the humans had written.
Must be proprietary, bc TOTP shouldn’t be blocked by age of the device
What do you do for a living/what are you into that isn’t super deep in some way? What field did you rabbit hole into in the past that makes you go, “never again”, now?
I think people are being lazy, in a selfish, tragedy of the commons sort of way.
When standing in line, they all watch the customer stand there doing nothing as the cashier checks out items. If only they’d bag their own things, we’d all be able to get on with our lives that much sooner. Instead, they continue standing there doing nothing, as the cashier now bags their items.
Then the next person in line moves up and also just stands there, also unwilling to do anything to help speed things along.
Thank goodness for the Hippocratic origins of healthcare. Wish I could throw his words back at him so he could hear how insane it sounds in the context of healthcare. Just imagine:
You think a doctor sits back and says, ‘Gosh, how can we get the price of saving this patient’s life down?’ No, it’s like, ‘How high a price can I get and maximize the profit for my shareholder?’"
But surely there’s a practical middle between “shoot first, ask later” and “sit and wait an hour”
It’s difficult to consider them pollution even if we were to accept the subjective opinion on displeasing aesthetics.
The pollution we’re all concerned about tends to be:
Even light pollution, which is arguably barely physically harmful, has all of the remaining qualities (or nearly) for sure.
If these qualities even apply wind generators at all, they do so very weakly. They can be moved/unbuilt, the “free market” is pricing them cheaper by the day, and if you really don’t like looking at them, it’s not impractical to avoid them.
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 objflat_map(func), i.e. (“bind”) to un-nest one level whenfunc(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
forloops – 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
forloops via interlacing andifchecks 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.