23,650 karma · joined October 15, 2013
The German equivalent is that everybody is complaining about rising rents in city centers because everybody wants to live in city centers. Home ownership in Germany basically means that you'll have to pay it off for the rest of your life anyway (and that's not a new phenomenon) so in the end there isn't all that much difference to renting finance-wise, except that renting is usually much less hassle.
Isn't this exactly "spend the youthful years struggling and get to enjoy the fruits when you are older"? ;)
PS: also, what's the obsession of young people with home ownership
Lol ok that's where you're coming from. Reducing music videos to gangster rap shite is basically the equivalent of "all movies suck because I've ever only seen Hollywood superhero movies".
E.g. this ancient Frank Zappa interview about the decline of the music industry is still as relevant as ever:
https://ziglang.org/documentation/master/std/#src/std/heap/d...
For higher level code, "generation-counted index handles" might be the better solution to provide temporal runtime memory safety, not part of Zig the stdlib though.
Or even better: never use dynamic memory allocation and make all lifetimes 'static' :)
https://floooh.github.io/tiny8bit/help.html
TL;DR: first press F1, then Space.
https://github.com/floooh/chips
The chips-test repo has the 'integration' code which assembles the headers into executables:
https://github.com/floooh/chips-test
There's also a similar project in Zig (but less complete, it's more like an experiment what the same implementation ideas would look like in Zig) that might be a bit more readable and with everything in one place:
https://github.com/floooh/chipz
E.g. start reading the top-level emulator executables:
https://github.com/floooh/chipz/tree/main/emus
...and then move your way down to the system implementations:
https://github.com/floooh/chipz/tree/main/src/systems
...and finally to the chip emulators:
That's the whole idea of software libraries, no AI needed for that ;)
It just takes some disciplines and not listening to the DRY crowd too much to create actually self-contained libraries.
The proper and uptodate URL is:
https://floooh.github.io/tiny8bit/
Apart from the 'pin-emulation' the other interesting feature is that the CPUs are 'cycle stepped', e.g. the CPU no longer has a special 'controller role' in the system but is just 'ticked along' with all the other chips. This blog post describes how that works for the Z80 emulation (the instruction decoder is still a big switch-case, but with one case-prong per instruction cycle instead one prong per whole instruction: https://floooh.github.io/2021/12/17/cycle-stepped-z80.html)
I didn't really get around to work on the project since 2023 though (and before that I worked on it mainly as a 'vacation project' over the Christmas breaks), I mostly just updated the sokol and Dear ImGui dependencies since then, and sometimes added new scene demos appearing on https://www.pouet.net/ and https://csdb.dk/.
But in any case: with 'sign-agnostic' integer types high level languages would simply need separate signed vs unsigned mul/div operators. Not a big thing when modern languages already have different operators for wraparound vs overflow-checked arithmetic (for instance + vs +% in Zig).
Beyond that, the decision whether a number is signed or unsigned is only needed for string formatting (e.g. it's like Schroedingers integers: whether a number is signed or unsigned only matters when you actually look at the number).
As for PRs: well yeah of course, when in Rome...
A better rule of thumb is to always use signed integers, except for bit twiddling and modulo-math.
Especially with 64-bit integers it's really no longer an issue to lose one bit for the sign (63 bits ought to be enough for anybody heh).
Still though: Amiga 4 ever! :D
Hmm... I'm using ghostty (on macOS) since it was released and have yet to encounter a single bug. Iterm2 simply got too fat and slow over time, which was the point where I went terminal-shopping (first wezterm, which is also fine, now sticking with ghostty).
"Because the Earth's rotational speed varies in response to climatic and geological events, UTC leap seconds are irregularly spaced and not precisely predictable."
I prefer a middle ground between strong and weak typing (but yeah, C is arguably too weakly typed, but the exact sweet spot is different for every programmer).
A reasonably smart C compiler that has visibility on all code in a project could theoretically infer a lot of the same semantic details that must be manually provided in Rust by looking at how the pointer is used in the wider codebase (basically what static analyzers are doing by reconstructing control flows). Of course such an extensive analysis would result in even worse compile times than Rust ;)
The Rust stdlib has a lot of essential low-level types needed for adding a 'semantic layer' on top of the language so that the language user can exactly 'express intent' (types that arguably should be language features instead). Just look at all those detailed methods needed to make RefCell work, and what does 'into_inner' or 'undo_leak' even mean?
https://doc.rust-lang.org/std/cell/struct.RefCell.html
E.g. what's a single concept in C (e.g. "the pointer") easily has a dozen specialized equivalents in Rust, just because Rust needs the additional information to do its memory safety magic correctly.
The entirety of Rust and its stdlib has a huge 'semantic surface' compared to most other languages (even C++), and I think this difference in the semantic surface size to other languages is exactly the one thing that either attracts or repels people to/from Rust ;)
Going from Rust to C++ seems a strange choice, since you get most of the same problems just without memory safety. Zig, Odin, C3 or even plain old C though? At least those languages have things to offer that neither Rust nor C++ provide (and if it's just compilation speed).