Pretty much the only thing I agree with is that computer architecture could use a complete rework (both from a software as well as hardware side, though primarily the former); as well as said rework being basically impossible in practice.
229 karma · joined March 18, 2015
Pretty much the only thing I agree with is that computer architecture could use a complete rework (both from a software as well as hardware side, though primarily the former); as well as said rework being basically impossible in practice.
That's how I learned that forest ants, at least the local ones, are incredibly docile. I never got bothered by them.
Mind, I haven't actually used it in anger, as I prefer full file sync vs on-demand.
And I haven't tried it ... unfortunately, the Android app is also ...... buggy.
Most sites didn't need a banner. Even post-GDPR, many use-cases don't need one.
There's also a very good TED talk on this topic from 8 years ago: https://www.youtube.com/watch?v=iFTWM7HV2UI
To be honest, I've been (slowly) working towards my own native GUI library, in C. It's a big undertaking, but one saving grace is that --- at least on my part --- I don't need the full featureset of Qt or similar.
My plan for the portability issue is to flip the script --- make it a native library that can compile to the web (using actual DOM/HTML elements there, not canvas/WebGL/WGPU). And on Android/iOS/etc, I can already do native anyway.
Though I should add that a native look is not a goal in my case (quite a few libraries already go for that, go use those! --- and some, like Windows, don't really have a native look), which also means that I don't have to use native widgets on e.g. Android. The main reason for using DOM on the web is to be able to provide for a more "web-like" experience, to get e.g. text selection working properly, as well as IME, easier debuggability, and accessibility (an explicit goal, though not a short-term one --- in part due to a lack of testers). Though it wouldn't be too much of a stretch to allow either canvas or DOM on the web at that point --- by treating the web the same as a native platform in terms of displaying the widgets.
It's more about native performance, low memory use, and easy integration without a scripting engine inbetween --- with a decent API.
I am a bit on the fence between an immediate-mode vs retained-mode API. I'll probably do a semi-hybrid, where it's immediate-y but with a way to explicitly provide "keys" (kind of like Flutter, I think?).
"Everything is a file" is not a bad abstraction for some things. It feels like Linux went the route of a golden hammer here.
I know it's not the most elegant thing ever, but if it needs to be JSON at the post-signing level, why not just something like `["75cj8hgmRg+v8AQq3OvTDaf8pEWEOelNHP2x99yiu3Y","{\"foo\":\"bar\"}"]`, in other words, encode the JSON being signed as a string. This would then ensure that, even if the "outer" JSON is parsed and re-encoded, the string is unmodified. It'll even survive weird parsing and re-encoding, which the regex replacement option might not (unless it's tolerant of whitespace changes).
(or, for the extra paranoid: encode the latter to base64 first and then as a string, yielding something like `["75cj8hgmRg+v8AQq3OvTDaf8pEWEOelNHP2x99yiu3Y","eyJmb28iOiJiYXIifQ"]` --- this way, it doesn't look like JSON anymore, for any parsers that try to be too smart)
If the outer needs to be an object (as opposed to array), this is also trivially adapted, of course: `{"hmac":"75cj8hgmRg+v8AQq3OvTDaf8pEWEOelNHP2x99yiu3Y","json":"{\"foo\":\"bar\"}"}`.
The big issue for me was the lack of support for nested observables in Svelte, which caused no end of trouble; plus a lack of portals (though maybe the new snippets fix that?).
That's because Microsoft, in their infinite wisdom, decided that a reasonable default was to use a whitelist of allowed senders, blocking everyone else by default.
There is supposedly a process to get that unlocked, but they never replied to my own request ...
Then they got bought by another bank ... and now, they require *6-digit* PINs/passwords + no certificates. Yes, there's 2FA involved now, but seriously, 6 digits?
I have a 3-way split:
1) core.* - basic support things like builtin traits, etc; this is the only namespace/prefix that is "special" to the compiler
2) std.* - things you might see in a minimalist stdlib. String manipulation, some useful algorithms, math, etc.
3) etc.* - technically part of the package ecosystem, but officially supported. All the usual suspects like advanced I/O, networking, base64, and whatnot would be found here. Making it part of the package management means it can be versioned independently from the compiler and in principle even broken between major versions (not that I'm planning to, but design mistakes happen)
(Exact name of "core" TBD)
I find that, at least with dentists, the quality seems to be an inverse function of their experience.
I've gone through a lot of dentists recently (long story, but nothing to do with quality of dental work), and I've consistently found that the younger/"inexperienced" dentists use more modern/advanced[^1] techniques, whereas the older ones tend to favor sticking to what they learned in a medical school years ago, plus an occasional conference or such. As opposed their very foundation being based on more up-to-date knowledge.
[^1] Unlike in software, this often translates to "better", at least from my experience as a patient.
---
Apparently this is somewhat of a problem in computer science for 50-something year olds, where one can sometimes find it hard to find a job. Companies prefer younger, more "malleable" candidates.
---
There is also the general fact of life that experience often brings hubris & arrogance. This is definitely not always true, but it's another case where more experience is actually worse.
These definitely need to be enforced better.
Namely:
1. Should the "default" (syntactically-sugar'd) arrays in the language (e.g. `int[]`) be restricted to simple contiguous storage, or should they also hold (potentially negative) stride, etc?
2. Should I have multidimensional arrays? (to be clear, I'm talking about contiguous blocks of data, not arrays-holding-pointers-to-arrays)
3. Should slicing result in a view, or a copy? (naturally, some of these options conflict)
I'm honestly erring towards:
1. "fat" arrays;
2. multidimensional arrays;
3. slicing being views.
This allows operations like reversing, "skipping slices" (e.g. `foo[::2]` in Python), even broadcasts (`stride=0`) to be represented by the same datastructure. It's ostensibly even possible to transpose matrices and such, all without actual copying of the data.
But there are good arguments for the reverse, too. E.g. "fat" arrays need 1 more `size_t` of storage per dimension (to store the stride), compared to "thin" arrays. And a compiler can optimize thin ones much better due to more guarantees (for example, a copy can use vector instructions instead of having to check stride first). Plus "thin" arrays are definitely the more common scenario and it simplifies the language.
So, yeah, still not quite sure despite liking the concept. One obvious option would be for `int[]` to be a thin array, but offering `DataView<int>` [1]. The problem with that is that people implementing APIs will default to the easy thing (`int[]`) instead of the more-appropriate-but-more-letters `DataView<int>`. Ah, dilemmas.
[1] (not actual syntax, but I figured I'd use familiar syntax to get the point across)
[1] Region locking is a form of DRM, and most DVDs at least used to be region-locked. I don't know if that's still common practice nowadays.
Also note that publishing to a particular high-profile comp sci journal tends to cost on the order of 1000 EUR (last I checked, a few years ago), more if you want it to be open/public access.
In other words, journals will:
- Charge hundreds to thousands of EUR to authors (typ. indirectly, by charging their university) in order to publish papers.
- Charge hundreds of EUR (at best) per year to readers for access to said papers.
- Not pay reviewers for the work in reviewing the papers.
It's literally just glorified super-expensive webhosting.
This is typically done in under the guise of notability ("GPL/copyleft is notable, other alternatives aren't").
Implying that music companies would have been richer than all the nations + other companies in the world combined, if it wasn't for music piracy. It's not hard to see how that's bull.
[1] The act of making a backup is not in and of itself (as it's considered a fair use/exception in most [not all!] jurisdictions, even outside of US), but it often involves circumventing DRM, and that part is piracy.
It exists for Android, but not desktop (judging by a number of dead links, it looks like it used to exist for desktop).
(or s/Gecko/Servo/ if desired)
In the case of a bridge, in terms of material, time, and money. In software, it depends on the program, but it's usually some combination of performance (e.g. encryption), cognitive overhead (remembering passwords, access policies, ...), accessibility, development time, and a few other things. And notably (for Wayland), features --- locking down a system naturally reduces what a system can do. Note that this overhead can be a blocker. Accessibility is an obvious one (e.g. take those numeric keypads that randomize the order of digits presented on the display each time you want to unlock them --- blind people will not be able to use those), but features can also be a problem: if part of my work requires commonly taking screenshots (e.g. because I work as a technical writer, and need screenshots for documentation reasons), then I won't be able to do my job. In fact, the corporate world is chock-full of (maybe even sensible!) security policies reducing efficiency of workers, or sometimes outright blocking work.
What I'm trying to get at is, security requirements depend heavily on each user and use-case. And I think Wayland's fallcy was in trying to shoe-horn everyone into this vision of a fully-sandboxed world without considering the practicalities and what people actually want or need.
For example, I keep my personal desktop (which I mostly use for gaming & FOSS work) far less secure than my work computer (which is also in my apartment, as I work from home). Because I've deemed the overhead of trying to better-secure my desktop, unlikely to get stolen from my apartment, as unnecessary overhead. Meanwhile, my laptop, which I also use for gaming & FOSS work, is more secure, as I tend to take it with me when I go on a trip. Because while the severity of a breach is the same as for my desktop, the probability is much higher.
So I have three situations, and I'll argue that no single security policy would be a good fit for all 3: (or even two) - Home desktop => low risk of breach, moderate impact if breached[*] => low security - Home work PC => low risk of breach, high impact if breached => high security - Laptop => moderate risk of breach, moderate impact if breached => medium-to-high security
That, I think, is part of the issue people have with trying to sell Wayland's flaws as "security". It's basically a one-sided "I'm changing the security policy, and you better pray I don't change it further". When said security might be more than just undesirable, but an active obstacle. At the end of the day, Wayland is a tool. It has a job and a purpose, and yet it can't even properly do some things of the tool it's meant to replace. Because "security".
([] If you disagree that it's an overhead, then I'm going to expect that every single door in your home, even the fridge & closet doors, are packed with as many heavy-duty locks as will fit on the physical door. And that each door is always locked unless you're currently actively interacting with the door. For starters.)
([*] Yes, I realize the issues with an attacker being able to access all my accounts and such, but I'm putting it in relative terms compared to the work PC.)
I used a ballpark of 30000 EUR of a difference (which is also very close to the current exchange rate!), and the result: 300 000 km.
Note that this doesn't mean that you have to drive for at least 300 000km, because electricity isn't necessarily free. Therefore, the number is likely to be higher. Also, realistically, one will likely need at least 1 battery replacement (~6000 EUR, as far as I'm aware) during this time.
THAT SAID, as fuel prices go up, the required "break-even" distance is going to decrease, as `km / EUR` you get with fossil fuels decreases.
((I had to.))
I use it both as a desktop and on my personal servers (most of them). Also used it in professional capacity in the past.