As a beginner use the editor built in on the website instead (called ID). JOSM is a great power user tool, but this article's recommendation to use it for your first edit is misguided.
5G seems pretty widly available here in Sweden in my experience, even in the countryside. Not that the speeds are actually better than 4G, but the indicator say 5G as I'm writing this in a tent in the middle of nowhere. :)
On raw coverage of 5g, only a few much denser countries are better. You live in basically the best 4g and 5g covered, sparsely populated country on earth :) most countries are not just further behind.
American cities also generally seem to have good 5G coverage with 4G frequencies being repurposed for 5G and 4G overall being put on life support as it’s phased out
Yes, and even in Europe. The demand-led need was badly misunderstood or anticipated in my opinion as operators were hesitant to invest (and some big ones still are). In this sense, 7G is a pipe dream (but of course worth researching as such).
Don't just look at the indicator on your phone though. Providers are free to scheme with those. Some honestly show the icon when you are on 5G. Others use the option of showing it when you are on 4G (not even 5G NSA) but the network offers 5G on the cell.
The marketing guys got involved with this indicator and completely ruined its trustworthiness.
I've been away from Twitter phone nerds scene for quite a while, what do they use now for those details? Is it still ##service## or something else entirely?
With 5G in particular I think it's important that people talk about which specific technologies they're referring to.
In the US at least, low-band or extended range 5G is widely available and has been for some time (and I'm talking about the "real" 5G low-band, not the BS marketing speak AT&T used for a while). Mid and high band 5G, or 5G ultra capacity, is much less available but if course it only really makes sense in dense cities.
I'm surprised that low band 5G isn't widely available in most 1st world countries, as again it's been here in the US for many years now.
As someone who coded C++ (15+ years) and later Rust (about 4 years now) for my dayjob: there are more than those you listed I have seen commonly. Unaligned accesses is a perrenial favourite, as is ODR violations and reliance on the undefined order of static constructors between translation units. In C++ I didn't see much of unsafe casts, except related to enums (always specify an underlying type to mitigate this).
Rust protects against all of these, but if you think Rust is only about memory safety, I don't believe you have seriously tried it. It does a lot of things in std API design as well to steer you away from bugs. Some examples:
- The pervasive use of Result and Option makes it impossible to forget to handle (or forward) the error case.
- Because of usage of RAII (C++ has this too, but not as pervasively, C doesn't except using some very new GCC extension) it is very hard to forget to free resources such as files, sockets, database connections, mutexes, etc.
- Enums can carry payload in their variants (C devs: think tagged unions, but safe, C++ devs: think std::variant but with match/case rather than bulky visitor pattern), which means you can make API designs that cannot represent invalid states.
- The typestate pattern is a bit hard to explain briefly, but it allows a state machine with types at compile time, to make sure you dont misuse an API. For example it can be used to prevent forgetting setting required fields in a builder before building. Or in embedded microcontrollers to make sure you can't hand out the same GPIO pin to different parts of the code base.
I often find that my code in Rust works first try, while that almost never happen in C++ for non-trivial code. It is what all those Haskell devs were talking about all these years, but in a systems language (no GC is critical to my day job in hard realtime control systems) and without the incomprehensible abstract math lingo.
I was only speaking for C not C++ (I fled C++ a long time ago). My code usually works first try in C, but my experience also working with students is that you need to learn to use safe patterns and strategies first. I can imagine that Rust enforces those.
You can do a lot more in C too: You can design safe interfaces based around incomplete structure types. This also should allows what you call typestate pattern (if I understand it correctly). You can build a decent option type / result type. You can have a bounds safe vector type. You can have safe string types. One can have type-safe dynamic casts. One can annotate return values so that they can't be ignored. One can use many different tools for safety. People coming from C++ often think that one can not do this in C because "it lacks abstractions", but this is not really true.
It has been a long time since I coded C. Last I did I remember hating C strings and the standard functions for dealing with them. So easy to get buffer overflows. I'd rather have the language design be so that I dont constantly have to think about not tripping over various things, instead I want to focus on the hard and interesting domain specific problems.
EDIT: Also, errno is an awful design. Forgetting to check for errors, or screw up which error you report is so easy in C. Exceptions in C++ are also bad, it is very easy to have no idea what exceptions are possible 5 layers down and end up with unhandled exceptions.
True, if you do pointer arithmetic on C strings or similar low-level buffer operations without introducing safe abstractions, there is basically no way to do this safely.
And I think that illustrates my point well. Yes there is MISRA C++ and CERT for C when you write safety critical code. But that is a lot of extra rules to follow and remember (and have linting tools check where possible). It is basically a entirely separate dialect of the parent languages. And if you aren't doing safety critical you won't be dealing with these but have to come up with your own (company specific or individual) rules. (You dont want to write MISRA C++ unless you have to, large parts of it are quite miserable).
In Rust I get good defaults, and a language that guides me in the right direction. The rules for safety critical rules are somewhat still under development but so far they look a lot shorter (you still need the "don't allocate in hard realtime tasks except at startup" and similar rules for example). And if you aren't doing safety critical you can safely use all of the language as long as you stay away from unsafe.
And for most code you dont need unsafe, and even when you do someone else has likely done the hard work for you already, providing safe abstractions on top. (The exception is FFI to other languages, it is impossible to avoid unsafe when calling code in another language that the compiler can't reason about, you should build a safe Rust API on top of the raw bindings. For popular libraries this often already exists.)
And my point is that "do not do low-level pointer arithmetic" is not really much harder to follow in practice than do not use "unsafe". In safety critical systems you may also care about panics, memory leaks, etc. I am not sure this is so simply in Rust as well.
That you do not get safe libraries out-of-the-box in C is a major problem. But I also see the supply chain situation in the Rust world as highly problematic.
Two counterpoints: Searching for "unsafe" is a lot easier when you want to audit the code (there is even a lint you can enable to forbid all unsafe in a crate (library)). And there is a pervasive culture to avoid unsafe where possible and document all the unsafe you do have explaining why it is in fact ok.
There are also experiments in formalizing the safety comments with attributes. To me the current prototypes look halfway towards formal verification, with unsafe functions specifying named requirements that must be upheld when calling them and the callsites needing to "discharge" them by name. Time will tell if this is a good idea for general code and it it catches on.
I agree that searching for "unsafe" is easier, we should have this in C too. I have some local patches to GCC that emit diagnostics for some things which are unsafe in C and were GCC does not already have a warning. I think the culture is an important point, the question is how this scales when the community becomes larger and then the share of well-paid enthusiastic Rust early adopers make way to tired, less interested developers that inherit a lot of code and have to get some things to work with limited time...
For a static blog you dont need that. My blog made the (near bottom of) HN front page last year. I didn't notice a thing until I looked at the traffic report (using goaccess). Static site generator with the result served from a bottom of the barrel Hetzner VPS, using nginx.
If a blog needs "scaling" of any sort you are doing it wrong.
The DSL (domain specific language) for defining data formats in ImHex seems really cool. I have never seen a language that mixes logic into definitions of data structures quite like that before.
It wouldn't at all suit a general purpose compiled programming language (the best you can do there is templates or similar), but here it seems really neat. I haven't looked into it (maybe this exists), but I would love to see this DSL as a library or a code generator, to help with parsing custom binary formats in my own programs. This is much easier for this specific purpose than even parser combinators (which is what I would typically use, e.g. winnow in Rust).
Interesting. Though after looking at the examples on their home page and skimming the examples it looks more limited than the imhex format. But that could just be because I don't know this library well enough.
How is this undo different than Git's reflog? Genuinely curious, while I have heard of jj I haven't yet tried it (I read it couldn't handle git submodules, which would have made it dead in the water for my dayjob, that seems to still be the case).
1. Reflog is very ref specific that is it tracks head. JJ has op and evo logs that do that + a bunch more they track everything about the repo every possible action. It's hard to explain with going into technical depth but you can read up on it.
2. Yeah submodules aren't supported but since you can use jj in a git repo you can commit git stuff via git like submodules and then enjoy the world of jj. Since submodule interactions should be rare imho. I use it for a bunch of projects with submodules.
reflog can't quite catch every change that might happen because not everything is stored directly as a ref (ie a "head" that git tracks, like a branch pointer).
For instance, if you are interactively using `git bisect` and you mark commits as good or bad, and you accidentally mark a commit incorrectly, you have to do something like:
The reflog can't really capture this kind of thing, hence why you have a bisect log -- now a wholly separate concept that exists independently of the reflog.[1]
Another example is when you do something like screw up an interactive rebase. Let's say you rebase 20 commits and then you get a conflict on commit 8. You fix the file conflicts, and continue. You accidentally solve the merge incorrectly, continue and get another conflict -- but only realize your mistake after you start solving it. The reflog can't save you here. You have to completely abandon the rebase and start over. (This specific example might be handled better these days).
I think the biggest thing about `jj undo` is that it works everywhere. You can undo rebases, merges, conflict resolutions, copies, deletions, whatever. The secret behind it all is that internally, jj is architected in a way where implementing a feature looks like you are working with a transactional database. You actually have `begin_transaction()` and `commit()` methods in the codebase that will make changes to the commit graph visible in an atomic way. When a command like `jj rebase` happens, all of the changes it makes are inside a transaction and committed at once. Every operation in the repo is a transaction, and it all goes into a log, which records the effects of a transaction -- very much like a database system!
So "undo" just means "undo the effects recorded in a transaction" and that is about all. And so it works for everything! And this design is very easy to intuitively understand and program against, as a maintainer, along with our other high level internal APIs. Any developer can easily write code that Just Does The Right Thing and the user can undo it and it's no big deal. When I develop and work on Jujutsu myself -- like I'm actively developing new features or prototyping ideas -- I almost always _use my own jj repository_ as a test repo while testing my builds.
In contrast, Git does not have one unified "transactional" layer for things like this. But not all is lost, there has been work on 'git undo' and it was implemented by... Someone who is now a Jujutsu maintainer[2]. :)
[1] Technically we do not yet have "step by step" bisect with good/bad yet (only "automatic" bisect that is one-shot), so that is something Git can do we can't do at all right now, but bear with me. :')
Git reflog is a per-ref log of its previous values. JJ operation log is a whole-repo atomic journal of changes. It's much more powerful. You can e.g. undo a change deep in history that already had multiple descendant branches (that jj rebased for you).
Since jj snapshots the commit you're editing a lot, you can often even jj undo an accidental edit to a just-created file that in git would have still been uncommitted.
I found exactly the discovery fulfilling in Dwarf Fortress, Rimworld and Minecraft. Once I mastered those (well, maybe it is fairer to say "once I plateaued", there are way more skilled players than me) I found much less interest in them. Sure, I still play occasionally for a bit after a big update drops, but that is pretty much it. Oh and yeah, puzzle focused games (as long as it isn't slide puzzles) are great too. I fondly remember Myst, Monkey Island and other puzzle games like that.
Some people like games where you need to grind (idle clicker games seem to be purest/insanest form of that), and that is something I don't get at all. It is just pointless busywork, just like those repetitive achievements ("kill N enemies with X style attacks") or collectables. (Achievements that are on the form "find this hidden thing" or "do this out of the box thing once" I do understand more.)
There are peer to peer (or otherwise decentralised, e.g. multiple servers operated by many different people) alternatives to Signal. I haven't tried any of them, nor do I know which ones have been audited. But if the worst comes to the worst, there are alternatives that are hard to block.
In particular I remember reading about DeltaChat which piggiebacks on normal email infrastructure, making it really hard to block without massive collateral damage.
Been using matrix for years now. Even operating a server for a small community. It is slightly more involved for regular users though so that is not the best but otherwise works.
Setting up your own federated instance is quite simple, there is an Ansible playbook around to make it even easier. You could even isolate it and have it only for your org.
From what I know there is some traction to get it adopted in a bunch of agencies eu-wide.
I loathe how difficult Matrix is for normal people though. It's a nightmare to find a client, get an account, connect to your server, set up push notifications, and then navigate to a chat, much less set up encryption.
Fine for us, my mom is never managing.
Hopefully if it gets more mainstream some of these things get smoothed out, because it's nice once it's working.
Huh, I guess that works. I never considered it as a Signal replacement. It always seemed closer to an IRC (and I guess Discord and maybe Slack) replacement to me. But yeah I do believe it has end to end encryption for individual communication as well.
Reading your and others comment I wonder what sort of refrigerators and freezers you have. Mine are about 10 years old now, Bosch, full height and whatever the best energy class was available at the time.
I'm very sound sensitive but rarely do I hear any noise from them unless I recently opened them for an extended period. Do we just have quieter appliances in Scandinavia than the rest of the world or something?
It works perfectly (except for the hum which has been there unchanged on and off as the compressor cycles for 31 years). I'm kind of used to it by now....
For lulz I checked and you can buy working models of this fridge at estate sales for $50-$110: the one pictured sold at a 2024 estate sale auction in Alabama/Tennessee/Georgia for $110.
reply