> On your side-project it's also ok to ignore best engineering practice, reinvent the wheel because you feel like it or make decisions based on what seems most interesting even if it's not a 'good' decision.

Pro tip for enjoying your life at work: this also applies to you work projects. Once you realize this, you can have a lot more fun at work and even coerce work projects to be more like your for-fun/side projects. Of course this is detrimental to the company as a whole, but your company almost definitely does not care about you and you might as well extract as much enjoyment as possible.

If your coworkers are actually passionate about programming (i.e. not drones or PM brains running flowchart to increase quarterly profit), you can even make work more enjoyable for them.

Things like unconventional language choices, over-engineering of systems, unusual coding styles, obscure protocol/library use, and of course a ton of NIH can really spice up a mundane codebase.

Even stretching an "easy" module into a masterfully crafted program and going 4x over estimation can be fun sometimes (without any of the bad design choices suggested above).

Yes I stand by this bad advice, and it's allowed me to play with so much technology I would never otherwise touch at day job.

>> On your side-project it's also ok to ignore best engineering practice

> Pro tip for enjoying your life at work: this also applies to you work projects.

While this may be fun for you and your team, in my experience it makes maintenance more difficult for the next team that inherits the project.

If you're going to do this please consider if you'd find what you're passing on to be acceptable if instead you were inheriting it.

It might be more fun for you than your team, just saying

> your company almost definitely does not care about you and you might as well extract as much enjoyment as possible

This is a very post-millenial attitude that explains in a nutshell a lot of the problems we have in society today.

I have worked with a lot of people who had this attitude. The main predictors for it in my experience are

1. Lack of faith in the company they work for, ie they don't fully "believe in the vision"

2. Love of tinkering and programming

I haven't noticed age factoring in at all. Working far far away from ant tech hub areas might be a factor as well.

>> that explains in a nutshell a lot of the problems we have in society

What evidence do you have for this?

I will use this when I need to explain the Chaotic Neutral alignment to my D+D players in the future. Thanks!

I'm pretty sure he has used gradient descent in previous videos to optimize systems, maybe this time it was just easier to hand tune rather than set up an optimization feedback harness around MuJoCo.

I was curious what information I could glean from these for some popular repos. Caveat: I'm primarily an low-level embedded developer so I don't interface with large open source projects at the source level very often (other than occasionally the linux kernel). I chose some projects at random that I use.

*Mainline linux*

Most changed files: pretty much what I expected for 1 and 2... the "cutting edge" of Linux development over other OSes -- bpf and containers. The bpf verifier and AMD GPU driver might get a boost in this list due to sheer LoCs in those files (26K and 14K respectively). An intel equivalent of amdgpu_dm is #21 in the list (drivers/gpu/drm/i915/display/intel_display.c) and nvidia is nowhere to be seen (presumably due to out-of-tree modules/blobs?).

    186 kernel/bpf/verifier.c
    174 fs/namespace.c
    162 drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
    161 kernel/sched/ext.c
    159 fs/f2fs/f2fs.h

Bus factor: obviously none. The top 4

    10399 Christoph Hellwig -> I only know his name because of drama last year regarding rust bindings to DMA subsystem
     8481 Mauro Carvalho Chehab -> I also know his name from the classic "Mauro, shut the fuck up!" Linus rant
     8413 Takashi Iwai -> Listed as maintainer for sound subsystem, I think he manages ALSA
     8072 Al Viro -> His name is all over bunch of filesystem code

Buggy files: Intel comes out on top of GPU drivers this time (twice). Along with KVM for x86(64), the main allocator, and BTRFS.

    1477 drivers/gpu/drm/i915/intel_display.c
    1406 MAINTAINERS
    1390 sound/pci/hda/patch_realtek.c
    1102 drivers/gpu/drm/i915/i915_drv.h
     943 arch/x86/kvm/x86.c
     928 mm/page_alloc.c
     871 drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
     862 drivers/gpu/drm/i915/i915_reg.h
     840 fs/btrfs/inode.c

*GCC*

Most changed files: IR autovectorization code, riscv heuristics tables, and C++ template handling (pt.c is "paramaterized types").

    152 gcc/tree-vect-stmts.cc
    145 gcc/config/riscv/riscv.cc
    131 gcc/tree-vect-loop.cc
    116 gcc/cp/pt.cc

Buggy files: DWARF debuginfo generation, x86 heuristics tables, RS6000(?!) heuristic tables. I had to look up RS6000, it's an IBM instruction set from the 90s lol. cp-tree.h is an interesting file, it seems be the main C(++) AST datastructures.

   1017 gcc/dwarf2out.c
    885 gcc/config/i386/i386.c
    796 gcc/cp/cp-tree.h
    740 gcc/config/rs6000/rs6000.c
    720 gcc/cp/pt.c

*xfwm4* Most changed files: the list is dominated by *.po localizations. I filtered these out. Even after this, I discovered there is very little active development in the last few years. If I extend to 4 years ago, I get: 1. src/client.c - Realizing this project is too "small" to glean much from this. client.c is just the core X client management code. Makes sense. 2. src/placement.c - Other core window management code.

This has not told me much other than where most of the functionality of this project lies.

Bus factor: Pretty huge. Not really an issue in this case due to lack of development I guess.

    3298  Olivier Fourdan
     530  Anonymous
     319  Xfce Bot
     121  Jasper Huijsmans

Files with bug commits: Very similar distribution to most changed files. Not enough datapoints in this one to draw any big conclusions.

I think these massive open projects (excl xfwm) are generally pretty consistent code quality across the heavily trodden areas because of the amount of manpower available to refactor the pain points. I've yet to see an example of "god help you if you have to change that file" in e.g. linux, but I have of course seen that situation many times in large proprietary codebases.

Big projects tend to self-correct. These commands hit differently on private codebases with 3-10 contributors, where high-churn usually means one person patching the same thing repeatedly.

This is better than the post itself. Showing real output from a real repo.

I don't think any realistic system will bootstrap C from shell. What is the shell implemented in if not C?

This shell.c can be compiled from c89cc.sh itself:

https://gist.github.com/alganet/1513d7b6abef5c1a53a324d897c3...

Ouroboros self-hosting. They can self-host one another.

The idea is to make shell.c compile from an even simpler C compiler, such as M2-Planet:

https://github.com/oriansj/M2-Planet

Let me remind you that current stage0 bootstraps tinyc from mes, which is an interpreted lisp. It's not that different from the shell architecturally.

The current stage0 also features kaem as one of the first dependencies. kaem is, in fact, a simpler version of the bourne shell.

It's always a tower. You'll never get a one single clean dependency pass in bootstrapping.

The shell.c ouroboros is really cool. Being able to bootstrap trust through an entirely different language family (shell → C → shell) adds genuine value to the trusting-trust problem beyond just technical novelty.

Even if your shell was compiled in C, it doesn’t mean it wasn’t cross-compiled from another platform.

He implied replacing nano was the first step, before using it for more complex (software development) tasks. First use it just for quick one-off edits of /etc/blah.conf then graduate to using it for longer editing sessions.

Rather than being about fast/simple/cheap, I think using SSN as a key was more about the fact that SSN is the only common identifier that almost all US citizens have.

I think you're using the word "key" differently than OP. You're talking about identifiers, and they're talking about security.

SSNs were a good potential identifier, until the people that needed security cheaped out and started using SSNs as a bad implementation of security. Now they're bad at both purposes!

Yes, designing and implementing a new common identifier almost all US citizens have would have been less cheap and fast.

Sure, but splitting "atomic" operations across a reboot is an interesting design choice. Surely upon reboot you would re-try the first `mv a b` before doing other things.

This is local to the device though. Nothing to do with the WAN. Would still work even on the "serverless" ipv6 network.

The Z80 instruction set lives on via the eZ80, Z180 and others which are binary compatible with the original Z80 instruction set. Unfortunately Zilog stopped making the 40 pin DIP package a couple years ago so yeah this specific board will be hard to source. You can still find them on gray market, mostly ones that have been desoldered from existing boards.

Even if you made a version of this board with the footprint changed to the QFP eZ80, it probably wouldn't work because the eZ80 has different memory mapping and clocking differences.

The Z180 has however had its PLCC packages discontinued. Personally, I find SMD CPUs to not be appealing for these sorts of projects, even if the Z180 is a great chip.

Really, the best we can do with the NPU is a less battery intensive blurred background? R&D money well spent I guess...