I find ants and bees and such interesting in this regard. They work together more seamlessly than humans do and arguably have a higher form of sociality.
Especially in Western cultures, we humans like to think of the individual and compare ourselves to the individual of other species. But that is a logical fallacy.
Are you smarter than an ant? Sure. But are you smarter than a human-sized ant hive? That’s a far trickier question to answer…
It should be noted that theoretically, we don’t know how this external API is implemented. The vast majority of APIs are REST APIs and with REST APIs, there’s a decent chance that you can download an OpenAPI definition from the server which provides the API.
REST APIs are basically APIs which use HTTP(S) for transport and then there’s some specific rules how the API should be designed. Often times, these rules are not strictly followed and people still refer to such an API as “REST”, because they assume that any HTTP API is a REST API. But yeah, similarly the guides you’ll find will likely also work with general HTTP APIs.
Sounds to me like they’re not trying to create a website for now, but rather just process some data, which they can later display in a static webpage.
So, I’m guessing something like this:
+--------+ +---------+ +----------+
| Static | | Their | | External |
| Web |---->| Own |---->| API |
| Page | | Backend | | |
+--------+ +---------+ +----------+
But yes, unless there’s a lot of data to crunch, the design one would usually go for is rather:
+-----------+ +----------+
| *Dynamic* | | External |
| Web |---->| API |
| Page | | |
+-----------+ +----------+
So, the data calculations would happen in the user’s browser. You would still need some hosting for that webpage, but there’s lots of free services to put a simple webpage up.
And yes, when you go with that latter design, then JavaScript would be the typical choice. It’s still possible to do it with Rust, using WebAssembly (e.g. a colleague of mine has built a small statistics webpage which gets data directly from GitHub, using the Leptos framework), but it is definitely the less beaten path.
Having said all that, frankly, fuck the usual way of doing things. If you’re comfortable with Hugo for frontend work, then I think it’s legit to build a little backend to take over the dynamic part. Better to build a useful project and learn something than to get stuck trying to learn the ‘correct’ path of doing it. Especially if you’d rather learn about Rust than JS.
Those Spectacle changes look good. The old UI made some amount of sense, if the primary use-case was taking complete screenshots, but even for that, there’s probably a single shortcut to do that directly.
And I do find, I generally want a smaller cutout these days, because you can just fit more stuff onto modern displays, some of which is going to irrelevant.
This song in some Cyrillic language: https://open.audio/library/tracks/102128
I think, that’s not a coral, but rather a dead tree next to a stream…
Yeah, the wording is confusing. A long time ago, there was no paid software, there was only software where you got the source code and other software where e.g. it was pre-installed on some hardware and the manufacturer didn’t want to give the source code.
In that time, a whole movement started fighting for software freedom, so they called their software “free”.
Well, it didn’t feel like I’m tweaking to my needs (that came afterwards on top), it rather felt like I’m just undoing design decisions that someone made to cater to their specific needs.
And I named the time mainly to give an idea of how much there was to tweak. My main problems were:
Well, that was just kind of one example to illustrate that it isn’t just a static screenshot, you actually see what’s going on in real-time. It’s also useful when you’re running a longer operation, like OS updates or encoding a video, and want to see when it’s done or that it hasn’t failed. You can just tell when the command output has stopped moving or a popup has appeared…
But thanks for the recommendation anyways!
I certainly think that it has many eccentric design choices. It’s not going to be for everyone. Some parts of it, I also think just look bad, which I had to customize. Well, and openSUSE’s theming made a big difference, too: https://simotek.net/tech/projects/opensuse-e/enlightenment-on-opensuse-13-2/nggallery/thumbnails
“Retro” is also definitely a word I would use, though more positively connoted. It has *different* eye candy to the usual desktop designs, which is a big part of the charm. In a sea of flat designs and tiling window managers, it stands out as its own thing.
I tried it a few years ago. I was really impressed by how lightweight and gorgeous it is. In particular, I found it really cool and actually useful that you got a live view of your other workspaces on your panel. You could even fullscreen a video on your other workspace and then watch (a very small version of) it in your panel.
But yeah, even though I came back to it multiple times, I never ended up sticking around. It would crash regularly (not the worst thing, since recovery was generally seamless, but still meh), but in particular, it had some peculiar design decisions.
For example, if you double-click a window titlebar in virtually any window manager, it will maximize. In Enlightenment, I believe it got shaded (i.e. the contents of the window got hidden and only the titlebar was still visible).
Another prominent one was that its applet for connecting to WiFi and such didn’t support NetworkManager, but rather only ConnMan. If you’ve never heard of ConnMan, yeah, I only know it from Enlightenment, too. Similarly, my distro (openSUSE) didn’t package it either (and openSUSE was said to offer a relatively good Enlightenment experience). That’s something which should just work, because you can’t expect people to look up how they can connect to WiFi while they can’t reach the internet.
And yeah, these are just the big ones that stuck in my head. There were lots of smaller usability issues, too. Many things you could fix by changing the configuration, but we’re talking many in an absolute sense, too, i.e. you might spend an hour or more just tweaking things so that they behaved like you might expect.
I mean, to my knowledge, it’s still Rasterman keeping most of the development together. You don’t need a ton of adoption when one guy tirelessly works on it.
Although I’m guessing Samsung probably sponsors him, so that’s probably quite crucial for him to be able to put that much time into it.
Sure, but that doesn’t actually happen in reality, that things just stop changing. Occasionally, you get rather isolated ecosystems where the changes go back and forth in a mostly self-contained manner and then adaptation might plateau for a bit, but at some point, a lightning or an earthquake or something will strike and then it’s back to adaptation.
Well, and those species which were the most adapted to this isolated ecosystem are also likely to die out then, rendering this temporary endpoint not exactly “ideal” either.
But it’s also not one singular endpoint either. Diversity is itself a strength, which helps species survive. This is particularly important where there is change, because external influences will affect different members of this species more or less strongly.
But even without change, splitting the work is beneficial. This can be as mundane as not everyone carrying around the equipment for bringing out the babies. But in particular with societal structures, it can also mean that the big muscle folks might do the muscly tasks and the big brain folks do the brainy tasks and those with claws for hands open up all the tin cans.
Evolution will not push past that to arrive at some hypothetical “ideal endpoint”, because that society with work splitting is fitter for survival than a monoculture would be.
Yeah, I hate that so much. Often times, it’s clearly just easier/cheaper to put makeup on a human actor, or at least for the aliens to be able to use the same equipment. But it’s so boring. If I want to see a humanoid with different skin color, I’ll visit my neighbor.
“Ideal endpoint of evolution” is itself a funny joke to those who participate in knowing things…
I’m guessing, this is what a drink carrier looks like, in case anyone else is wondering: 
The problem is that corporations are not holistic organizations. In theory¹, a company could not have any juniors and always just hire seniors from the outside. And if your boss has reason to believe that this is more cost-effective, then they have to strive for that, even if they’re well aware that it cannot work when all companies strive for that.
¹) In practice, I’ve actually found that juniors are important, too. If you staff a project team with only seniors, you quickly end up in a situation, where they don’t talk enough to each other. They know how to solve things technologically, so they don’t need to tell each other about their challenges and what solution they chose.
Similarly, you likely end up in a situation, where only big problems are being tackled, because everyone can tackle big problems and they’re just very visible, highly prioritized problems. But when you add up enough small problems, they become just as problematic.
If you run a build command on the CLI, it should tell you the full type names…
The conventional ternary is structured like a normal if-else. In fact, in many languages with functional influence, they’re the same thing.
For example, you can write this in Rust:
let vegetable = if 3 > 4 { "Potato" } else { "Tomato" };
It’s the same thing as ternary, just without the
? :syntax.