nurbl

Probably, but it is a good point: premature optimization is easy and fun because you're doing it while writing the code and it's already in your head. Optimizing a large, working, congealed codebase that you didn't write is often hard and feels risky, even with good test coverage. Very local optimizations, fine, but those requiring refactoring? Less likely to happen.

Maybe there's a golden opportunity somewhere inbetween where optimization is not premature but also not painful to do.

I agree that this makes sense for the kind of situations that the article talks about. If you only need to express common angles like 90 degrees, 45 and so on, radians are just messy (though in physics, you get used to it).

But in other cases, radians are useful. For example consider the case of small deviations from a direction. If you give it in radians, let's say three mrad (milliradians), it's very easy to estimate how large the error will be over the course of a meter; three mm.

This is just to say: choose the right unit for the job.

If you are a "digital art" community, clearly you have already accepted some digital tools.

I do think it makes logical sense to try and ban "AI" art if it is not what the community is interested in. It's likely not just about pretty images. They might value the mental process, the individual's style, progression, techniques, and yes, the effort. Someone coming in with generated images expecting to be treated the same is to me a bit like commissioning art from someone else, and then presenting that as your own. The images might be great, but it's not in the spirit of the community. There must be tons of "AI" focused communities for that.

I suppose they will eventually fail at resisting this, but that's another matter.

I think the point of the example is that in zig you'd just do

  if (mask.alpha and mask.blue) {

My PC sits in a place behind my table which isn't easy to reach, and I have my keyboard and mouse connected to the built-in USB switch in my monitor. Because the monitor turns off by itself to save power, there's no quick way to wake the PC from suspend mode (e.g. by pressing a key). However, I've accidentally found that turning off my desk lamp wakes the PC up! So just toggling the lamp and off will do the job. I guess it's somehow because the PC and lamp are connected to the same extension cord. The only inconvenience is that I sometimes forget to turn the lamp off before putting the PC to sleep at night.

It's pretty reliable - at least more reliable than the wireless IKEA light button in the kitchen...

Amen. Once I understood the game and started being able to play rationally, the main threat was always my own impatience. How many times I lost fights just because I forgot to stop and check my inventory for useful stuff. Or ran right into a floating eye in a dark corridor...

It's weird to me that even games that seem focused on story, atmosphere and graphics with pretty simple gameplay - like "Control" or "Death Stranding" - can manage to over-complicate it with confusing menus, lots of micromanagement of upgrades, pointless subsystems, etc. I like both these games well enough but I don't think I will ever get through them simply because I don't play often enough to learn all the fiddling.

This sounds like a good outcome. From my experience, the usual reason small labs setups use things like LabVIEW is that they are usually built by one PhD student without experience and this is the only way they can get something working in a reasonable time. But then the student moves on and the result is something that may work, but nobody can build upon.

Still, the situation you describe is unstable because as soon as the budget starts to look uncertain that engineer is likely the first to go. I really wish institutions would take this problem seriously and set up e.g. a department wide development group, which could help build and maintain stuff like that and ensure continuity. Unfortunately this seems to be against the current trend of cutting costs. For example, at the university I used to be, they cut the small common electronics shop, which was a great resource since the guys there knew all about who had what equipment, kept spare parts from broken stuff, etc. But in the budget it looked like pure cost I suppose. It's hard to measure the value of common resources and nobody wants to pay.

My fresh emacs startup time is a couple of seconds, not super snappy but then it has a reasonably large config to load. Reducing startup time is nice but I think vanilla emacs actually already starts quickly. How would you even be able to prevent people from adding heavy stuff to their config? It's possible to defer loading of packages until you need them but I think it would be hard to enforce by default, given that Emacs is really just a lisp machine and the config file is a lisp program.

I normally never exit Emacs. This is not because of startup time. To me it's like the web browser; I use it all the time, have a workspace dedicated to it and it's natural to keep lots of buffers open. My muscle memory takes care of jumping between open buffers.

I liked "Statik", a pretty clever VR escape room-esque puzzle game where your hands are stuck in a strange device which you can manipulate in various ways using the game controller. Some levels even allow a second player cooperating via a phone app.

Totally different game of course, but this reminded me of Katamari Damacy! In many levels you start tiny in a room somewhere, and have to roll up paper clips and thumb tacks in order to grow and roll up successively larger things, while avoiding gigantic pets, and so on. Apart from being hilarious and sometimes challenging, I also found it an interesting psychological effect to come back to the same place when you're 100 times larger, now able to roll up humans, cars, the entire house... :)

Katamari is a casual game (I prefer this genre) but now I wonder if there would be some way to make a more "simulationist" game that uses this scaling effect somehow.

One thing to keep in mind when moving from sqlite to an "out-of-process" database is that individual query overhead will increase a lot. With sqlite it's usually no problem to do lots of small queries and combine the result, but when you need to account for network latency etc it's a different game. This could be unintended; e.g. your ORM use causes lots of queries that you didn't know or care about with sqlite. You may have to rethink the way you do things in order to keep performance.

There's a lot of room for general python skills in various parts of science, and in my experience quite easy to get a job because there's not a lot of competition (mostly due to wages I guess). Often any libraries/frameworks in use are obscure and you're not expected to know them beforehand. Projects tend to be numerous and small rather than a single huge one.

Universities, large scientific labs/facilities, etc.

Having not managed to finish a Stephenson book since "Snow Crash" (which I liked) i may not be in the best position to recommend something to you, but I really like Greg Egan. Truly idea-driven SF which also has interesting enough characters and story. I also like that his books are pretty short, even his trilogy is probably shorter than any single Stephenson book. Very little "fluff".

It's easy to drop in Cython in an existing project where you need some performance, and start gradually "cythonizing" modules from the inside out. The rest of the code does not need to care.

With a bit of care (and benchmarking) you can get very respectable speed. The main drawback is that the further you go, the more C knowledge you need in order to not blast your own feet off.

If you're just after a bit more performance in general, a drop in solution like pypy might be enough.

A bit of a pain. But to be fair, this import was deprecated since python 3.3, released almost 10 years ago.

I'd just like to add that one of the most important features of a souls game is the fairness of it. It's almost always your fault when you lose; for reacting too slow, for rushing in, for not keeping your eyes open, for forgetting to equip the right stuff. You are punished for not learning.

I think the games feel hard compared to "normal" games because they don't hold your hand. If you see that and adjust, they are not that hard. They do test your patience, and force you to deal with frustration. Most games try their hardest to avoid this.

As an old nethack player I really appreciate this. I think in some ways, Souls is what nethack might have been if it was developed today.

Sean Carroll is my favorite interview podcaster. Maybe it's my physics bias but his guests are often from very different areas and he still finds good questions, keeps a humble attitude of wanting to understand, and doesn't take up too much room. The discussions stay on topic and often go pretty deep.

I think it's the game I've played that comes closest to feeling like a genuine mystery. Even though I think I've finished it, there are many aspects I still don't "get". It may just be that it's good at simulating this experience (sort of like a Lynch movie) but I don't think it matters. It's a great puzzle game wrapped in an enigma. And a piece of art too.

Or, perhaps they remind you of what didn't need to be done after all...

Thanks, I used gentoo quite a bit back in the day! Today I don't do enough file management to bother going outside emacs dired :)

Just to add some context, as far as I remember, gentoo was pretty similar to how DOpus worked on the Amiga until version 5, when it went from being a classic "one window, two pane, rows of buttons" thing, to arbitrary numbers of independent windows. DOpus 5 was really neat and powerful but also quite a different experience, more like its own desktop environment really. I hope I still have the ring bound manual somewhere...

The article seems to mix up "expert" with "world class" a bit. I do think that becoming one of the best in the world in any popular field probably requires suitable genes. But, to me, "expert" is more like someone who's usually the best person in the room at something. Quite different goals.

It's a matter of definition, but I feel technology can do more than just make our lives more comfy. Anyway my point is that the chase for comfort can actually hurt us. Maybe we should try some carpentry?

I see your point and I'm not contradicting you, but I do feel that this expectation of comfort is the main hook that locked down technology is using to get us. Once we're used to it we don't easily give it up. But I think it leads to passivity. And once everything is catered to the lowest common denominator, it starts to get in the way of any usage out of the ordinary.

Even without undo-tree, Emacs undo history is "persistent". By that I mean that changes aren't overwritten, so the statement in the article that undoing stuff and then making edits loses the undone changes is not true for Emacs. You just have to undo back through the new edits, then you will start to redo the old undone edits, and so on. It can be tedious, but just the knowledge that it's all there is quite liberating.

Another vanilla feature I sometimes use to keep track of old code is the "kill ring". Just cut the old code and it will be available in there later if needed.

Wouldn't it be more natural to do this sort of thing with decorators?

I obviously don't know what your users were thinking, or even what your application does, but for my part I use open source stuff because that means I know if I become dependent on it, and the original author drops it (or goes in a direction I don't like) I have options. The price is pretty much orthogonal. Just saying it's not necessarily just about entitlement and getting stuff for free.

Part of the point of citing another article is that you don't then have to repeat all of it. So if B is cited by A, and B is no longer available, it's not really possible to read and understand A either. And likely A used information in B to justify some claim, which is now weaker.

This reminds me of https://www.visidata.org/ which is a terminal based application with similar purpose - loading tabular data from various sources, and exploring and processing it in a visual way.

The article is pretty clearly written for someone who is already an emacs+org user. I guess it was posted mostly as a teaser of what can be done with it.

The "plain text" catch phrase is not baseless, though. One of the best things about org mode is that there really is a simple and intuitive markup format at its core. Most users probably only ever use the "outliner" features, which are pretty obvious. But once you're used to that, there are lots of more complex features you can start using, one by one. Or just ignore.

Being text, org mode files are also pretty easy to e.g. grep.