You can reference envs from the host in docker compose, so code it in instead of manually passing tribal knowledge in: https://stackoverflow.com/a/73826410

Simpler to keep everything in one compose file if you can, under a test service that doesn’t build unless explicitly named

Un-weird that env var and use the normal, boring feature of defining environment under your test service

I’ve often been able to alias drun='docker compose run --rm --build' and simplify down to:

drun test

Should be able to encode all those wayward args into docker-compose.yml or Dockerfile and only use vanilla docker commands – that’s the whole point of containerization

In the US? IMO only possible in exclusive environments similar to saunas at spas or membership-based clubs/gyms

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.

Idgi – is it saying that every game is either named “X” or “Y’s X”?

There’s the practical distinction between “everyone can do it with some dedicated intent” (so few actually bother) vs “everyone can do it on a whim”

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

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.

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.

Good code is code that’s easy to delete.

I’m not a game dev, but it’s got a reputation for being more of a software engineering shit show than other software industries, which your story only reinforces.

Fine for prototyping, but adds a scaling tech debt “time bomb” for a live system. Those associations had better be really sparse.

So… a polymorphic many-to-many join table?

If talking about a closed source app, their whole goal is to move off of hosting closed source systems.

Article says the decision follows a successful pilot project, so they’re willing to absorb the short term costs. Optimistically in the long run, the symbiotic benefits of having a government entity using and supporting a full FOSS system will be huge.

One of the best use cases is implementing abstract data types and hiding the memory management and other potentially unsafe optimization tricks behind a clean and high level abstraction.

Also since it’s a logical/mathematical construct and not attempting to model the real world (like business logic), it’s one case where inheritance hierarchies will remain stable.

I feel a lot of advice here is trying to push the learning envelope without considering fun & the learning experience. This is for an 8 yr old, and I’m seeing suggestions that would seriously challenge high schoolers, college students, and even some software engineers in industry I’ve encountered.

For the software aspects of programming, I would suggest looking at programming(-esque) games and web browser programming environments. Here’s a solid short list, vaguely sorted from “proramming-esque” to “actual programming”:

• https://upperstory.com/turingtumble/ - A physical algorithmic marble and lever puzzle “board game”. Great (and designed for?) for kids. Not programming.
• Factorio - A factory-building game that “feels” a lot like software development. Not programming.
• Opus Magnum - mechanical puzzle game by Zachtronics, build algorithmic “molecule-building machines”. Not programming.
• <Any other game by Zachtronics> - varies from “not-programming” to “contains programming”. Can get pretty difficult sometimes.
• Human Resource Machine - Programming puzzle game using assembly-like language. Later stages are challenging.
• 7 Billion Humans - “sequel” to Human Resource Machine, more featureful language, has concurrency and randomness. Later stages are challenging.
• https://www.hedycode.com/ - An innovative learning programming lang and “levels” method that makes Scratch primitive by comparison. Has free online lesson plan & environment. Hedy level 18 is vanilla Python.
• https://www.codecademy.com/ - you said you’re using this already

Suggestions to go physical tinkering with electronics is good, but I’m unable to make good suggestions there.

A real computer and coding environment/shell could be good for system admin skills, but the learning curve is steep. You’ll also have to be okay with letting him accidentally brick the computer (best way to learn!).

Disagree with Docker and git at this stage of learning. This is an 8yr old playing with scratch, Minecraft, and early levels of CodeAcademy.

The answer to “not dealing with environment” isn’t Docker, it’s a programming(-esque) game or an in-browser environment.