It scratched an itch I've been having, though very unexpectedly. I left it feeling quite decided and energized insofar as the significance of ritual in my life goes. It changed the way I think and feel about community. Or the lack thereof in my culture.
It isn't a prescriptive book at all, and perhaps very bleak in a sense. He describes how we've lost much of the ritual and innate temporal rhythms which have historically given us a greater sense of time, place, purpose, closure, and so on. Similarly, he suggests we live in a world now which is arguably incompatible with these things, because it is designed to eliminate the conditions in which this rhythm can exist at all. We're trapped in a sense. The thing we crave is mutually exclusive with the environment we now live in.
Similar to the Burnout Society, he writes a lot about our hyper-individualistic culture which is obsessed with personal optimization and productivity. These are not ideals which are conducive to communal, cultural events and connections which transcend the individual. Yet one could argue that they're quite important to humans, and increasingly absent from our lives.
Another important concept is the fragmentation of time and how everything now blurs together.
There's much more to it. I'm only highlighting the parts which stood out clearly and are coming to mind now. Like burnout, it's short enough to read in a day, and well worth it. Han really speaks to me and his essays are absolute page-turners.
If you want something a bit more substantial and argumentative where conclusions are backed with clearly established points and data, it isn't the right kind of read. He also doesn't offer solutions. For me the pleasure is derived from a sense of understanding, appreciating an eloquent perspective on something I feel I'm experiencing, and Han's signature ability to crystalize the malaise of contemporary life. I know some people who would find the book irritatingly thin in too many places, or lacking any kind of rigour in explaining how he arrived at certain ideas or why he's making certain statements. If you can see past that, it's excellent.
I think the key is remembering that he isn't writing a scientific paper or treatise so much as a provocative essay to share his exploration and wonder about an amorphous, vague, yet visceral and pertinent matter.
I'm my experience this is definitely where rust shined. The language wasn't really what made the project succeed so much as having relatively curious, meticulous, detail-oriented people on hand who were interested in solving hard problems.
Sometimes I thought our teams would be a terrible fit for more cookie-cutter applications where rapid development and deployment was the primary objective. We got into the weeds all the time (sometimes because of rust itself), but it happened to be important to do so.
Had we built those projects with JavaScript or Python I suspect the outcomes would have been worse for reasons apart from the language choice.
Rust is also a systems language. I am still wrapping my mind around why it is so popular for so many end projects when its main use case and goals were basically writing a browser a maybe OS drivers.
But that’s precisely why it is good for developer tools. And it turns out people who write systems code are really damn good at writing tools code.
As someone who cut my teeth on C and low level systems stuff I really ought to learn Rust one of these days but Python is just so damn nice for high level stuff and all my embedded projects still seem to require C so here I am, rustless.
If python's painpoints don't bother you enough (or you are already comfortable with all the workarounds,) then I'm not sure Rust will do much for you.
What I like about Rust is ADTs, pattern matching, execution speed. The things that really give me confidence are error handling (right balance between "you can't accidentally ignore errors" of checked exceptions with easy escape hatches for when you want to YOLO,) and the rarity of "looks right, but is subtly wrong in dangerous ways" that I ran into a lot in dynamic languages and more footgun languages.
I rarely if ever encounter bugs that type checking would have fixed. Most common types of bugs for me are things like forgetting that two different code paths access a specific type of database record and when they do both need to do something special to keep data cohesive. Or things like concurrency. Or worst of all things like fragile subprocesses (ffmpeg does not like being controlled by a supervisor process). I think all in all I have encountered about a dozen bugs in Python that were due to wrong types over the past 17 years of writing code in this language. Maybe slightly more than that in JS. The reason I would switch is performance.
Same. I like the type hints -- they're nice reminders of what things are supposed to be -- but I've essentially ~never run into bugs caused by types, either. I've been coding professionally in Python for 10+ years at this point.
It just doesn't come up in the web and devtools development worlds. Either you're dealing with user input, which is completely untrusted and has to be validated anyways, or you're passing around known validated data.
The closest is maybe ETL pipelines, but type checking can't help there either since your entire goal is to wrestle with horrors.
“The user can choose between starting their new policy on the first day of employment, the first day of the fiscal year, on a specific date, or some number of days after their prior policy expires. If they choose the first day of the fiscal year, the user must specify when their company’s fiscal year starts. If they choose a specific date they must choose a date that is after the first business day of the next month and no later than December 31st of the year that month belongs to. If the user specified some number of months after their current policy expired the user must provide a policy number and the number of days no less than 1 and no more than 365.”
Type validation can help with some of that but at some point it becomes way easier to just use imperative validation for something like this. It turns out that validating things that are easy is easy no matter what you do, and validating complex rules that were written by people who think imperatively is almost impossible to do declaratively in a maintainable way.
For me, ADT’s and pattern matching are about expressivity not type checking. Type checking really helps with refactoring quickly. If we’re measuring experience with years, I was a rubyist for over a decade and have written python for another 5 years after that, so I have some dynamic language bona fides.
I write scripts in rust as a replacement for bash. Its really quite good at it. Aside from perl, its the only scripting language that can directly make syscalls. Its got great libraries for: parsing, configuration management, and declarative CLIs built right into it.
Sure its a little more verbose than bash one-liners, but if you need any kind of error handling and recovery, its way more effective than bash and doesn't break when you switch platforms (i.e. mac/bsd utility incompatibilities with gnu utilities).
My only complaint would be that dealing with OsString is more difficult than necessary. Way to much of the stdlib encourages programmers to just do "non-utf8 paths don't exist" and panic/ignore when encountering one. (Not a malady exclusive to rust, but I wish they'd gotten it right)
Paths are hard because they usually look like printable text, but don't have to be text. POSIX filenames are octet strings not containing 0x2F or 0x00. They aren't required to contain any "printable" characters, or even be valid text in any particular encoding. Most of the Rust stdlib you're thinking of is for handling text strings, but paths aren't text strings. Python also has the same split between Pathlib paths & all other strings.
Yeah, the issue is that there are no utilities for manipulating OsStrings, like for splitting, regex matching, or formatting OsStrings/Paths.
For instance the popular `fd` utility can't actually see files containing malformed utf-8, so you can hide files from system administrators naively using those tools by just adding invalid utf-8.
touch $'example\xff.txt'
fd 'example.*txt' // not found
fd -F $'example\xff.txt' // fails non-utf8
The existing rust libraries for manipulating OsString push people towards ignorance or rejection of non-utf8 filenames and paths.
> having relatively curious, meticulous, detail-oriented people on hand who were interested in solving hard problems.... Had we built those projects with JavaScript or Python I suspect the outcomes would have been worse for reasons apart from the language choice.
I genuinely can't understand why you suppose that has to do with the implementation language at all.
> I genuinely can't understand why you suppose that has to do with the implementation language at all.
Languages that attract novice programmers (JS is an obvious one; PHP was one 20 years ago) have a higher noise to signal ratio than one that attracts intermediate and above programmers.
If you grabbed an average Assembly programmer today, and an average JavaScript programmer today, who do you think is more careful about programming? The one who needs to learn arcane shit to do basic things and then has to compile it in order to test it out, or the one who can open up Chrome's console and console.log("i love boobies")
How many embedded systems programmers suck vs full stack devs? I'm not saying full stack devs are inferior. I'm saying that more inferior coders are attracted to the latter because the barriers to entry are SO much easier to bypass.
npm isn't the issue there it's the ts\js community and their desire to use a library for everything. in communities that do not consider dependencies to be a risk you will find this showing up in time.
The node supply chain attacks are also not unique to node community. you see them happening on crates.io and many other places. In fact the build time scripts that cause issues on node modules are probably worse off with the flexibility of crate build scripts and that they're going to be harder to work around than in npm.
That argument is FUD. The people who created the NPM package manager are not the people who wrote your dependencies. Further, supply chain attacks occur for reasons that are entirely outside NPM's control. Fundamentally they're a matter of trust in the ecosystem — in the very idea of installing the packages in the first place.
Lack of stronger trust controls are part of the larger issue with npm. Pip, Maven and Go are not immune either but they do things structurally better to shift the problem.
Go: Enforces global, append-only integrity via a checksum database and version immutability; once a module version exists, its contents cannot be silently altered without detection, shifting attacks away from artifact substitution toward “publish a malicious new version” or bypass the proxy/sumdb.
Maven: Requires structured namespace ownership and signed artifacts, making identity more explicit at publish time; this raises the bar for casual impersonation but still fundamentally trusts that the key holder and build pipeline were not compromised.
For Go, there are more impactful features: minimal version selection and the culture of fewer, but larger dependencies.
Your average Go project likely has 10x fewer deps than a JS project. Those deps will not get auto-updated to their latest versions either. Much lower attack surface area.
I don't think cargo is much better in that respect. It's what happens when instead of a decent standard library and a few well established frameworks you decide that every single little thing must be a separate project.
> because it mistakenly treats a cause as having only one effect.
If A causes other things besides B, then knowing about those other caused things tells us nothing about whether C happened, because we already know it did. "no further information" is elided to things that are relevant to the statement being made. Please apply basic charity in interpreting ideas expressed in prose; LWers who want to express something precisely in logical or mathematical notation are certainly not afraid to do so.
> Less wrong is a bunch of people who think they understand Bayes better than they do.
The objection you point out is not relevant to demonstrating an understanding of Bayes' Law. It's just a semantic quibble.
Different programming languages come with different schools of thought about programming and different communities of practice around programming.
If you take a group of people who are squarely in the enterprise Java school of thought and have them write Rust, the language won't make much of a difference. They will eventually be influenced by the broader Rust community and the Rust philosophy towards programming, but, unless they're already interested in changed approaches, this will be a small, gradual difference. So you'll end up with Enterprise Java™ code, just in Rust.
But if you hire from the Rust community, you will get people who have a fundamentally different set of practices and expectations around programming. They will not only have a stronger grasp of Rust and Rust idioms but will also have explicit knowledge based on Rust (eg Rust-flavored design patterns and programming techniques) and, crucially, tacit knowledge based on Rust (Rust-flavored ways of programming that don't break down into easy-to-explain rules). And, roughly speaking, the same is going to be true for whatever other language you substitute for "Rust".
(I say roughly because there doesn't have to be a 1:1 relationship between programming languages, schools of thought and communities of practice. A single language can have totally different communities—just compare web Python vs data scientist Python—and some communities/schools can span multiple languages. But, as an over-simplified model, seeing a language as a community is not the worst starting point.)
I've personally implemented Playwright in a large enterprise company. Puppeteer before that.
Generally if you have a lot of legacy selenium scripts it's probably not worth it to switch everything over, but if you're creating a new UI automation framework I've just never seen selenium as a first choice for that.
Don't get me wrong it's still solid technology though.
yes, i've noticed some tendency for [agentic] qa services to go the puppeteer and then playwright route (sometimes either or). it's almost too easy to get running with pw. and, hence, enticing for any startup that wants to get off the ground asap and break even. seems vibium may tap into that startup market as it matures.
legacy selenium suites are a strong contender for vibium adoption. i think hugs has been surveying a ton of folks, he may have a better bird's eye view of the potential user base.
as for academic use of selenium, we have boni garcia - maker/popularizer or selenium webdriver manager teaching at a uni in spain. (maybe an isolated example, but he's rather known in the community)
i started the selenium project as just a js and python thing. but it got really popular in java circles.
vibium will also be a big tent project and support ts/js, python, java, and as many other languages we can support, too. but i started with ts/js because that's what's extremely popular right now. (and i like js!)
(side-note: i f'ing love nim, we will be supporting nim, too. getting nim on the tiobe top 20 is on my bucket list.)
I have a Hisense TV which recently did the same. It turned on personal recommendations and advertising. I have no idea where the ads are or how it works; I only use devices over HDMI. I'm sure the TV is spying on me incessantly nonetheless.
> Nobody ever complains about the person who’s leaving everything they touch a little cleaner than how they found it.
This should be true, but it's not in my experience. Even small, clear improvements are rejected as off-mission or shunted to a backlog to be forgotten. Like, "cool, but let's hold off on merging this until we can be certain it's safe", or in other words "this is more work for me and I'd really rather not".
Do it as part of ticket work you're already doing. There is always a way to leave things better than how you found them.
I have worked across a wide gamut of roles (full-stack eng, infosec, deploy infra, devops, infra eng, sysadmin), companies (big and small, startups and huge multibillion-dollar players), and industries (finance, datacenters, security products, gaming, logistics, manufacturing, AI) over a thirty year career and I have never felt the level of helplessness that people seem to be claiming. Some places have been easier, some have been harder, but I have never once found it to be as difficult or impossible as everyone laments is the case.
> There is always a way to leave things better than how you found them.
I agree, and that's something I do even if I get push back. I think it's essential in all aspects of life, or things typically get worse. People have to care.
My point is more so that it often—in my experience, at least—is met with friction because a lot of people see this kind of housekeeping as bad for bottom lines, or in the weeds, as a distraction, or what have you. I've encountered friction and push back more than acceptance let alone appreciation, I think.
A very common (and sometimes fair) form of push back is along the lines of "let's keep this ticket ONLY to the bug fix/feature/whatever and avoid any unnecessary changes". This is generally good practice, but I'll personally allow unrelated changes if they're relatively simple chores to leave things better than they were found.
If I were to summarize my experience, it's that caring to make things better or as good as they should be typically requires my own time and energy outside of regular work hours. That's a hard sell, especially after 20 years or so. I still do my best to make things better and I've come to expect and meet that friction with the necessary energy to overcome it, but... I mean, it's not always easy or necessarily rewarding. Many of my jobs could have often been dramatically easier if I cared less, but I'm not sure anyone would have even minded that.
My point isn’t that my experience is universal, but that I find it statistically unlikely that this is nearly as hard as people are making it out to be at the majority of SWE roles.
If you find yourself repeatedly working at places where the only option is to crank out garbage at breakneck pace, I don’t know what to tell you. If you stipulate as an axiom that it's impossible to write quality software at ${JOB}, then you're right, by definition there's nothing to be done. I just don't find that a particularly helpful mindset.
Many luxury items strike me as a sort of unnecessary burden. I do understand why sometimes they're nice and even worthwhile, but... I don't know, perhaps the issue is that in my culture, it's often the case that people conflate luxury with necessity, as though you're doing something wrong if you can't afford commercial luxuries by default.
At that point you're training yourself to carry unnecessary psychological burdens for virtually no gain.
I also find a lot of luxury items are kind of contrived and status-oriented rather than innately luxurious. Like, cool sparkling water with ice in summer is very luxurious to me in an innate sense. The simplest luxuries tend to strike me as the nicest and least likely to be contrived in order to separate me from my money.
I want to swim in clean, cool water. Sleep on a nice mattress with nice bedding. Cycle to work rather than drive. Have space in my home for hobbies. Have access to clean air. Have access to good food. Live in a city with a lot of green space. In the scheme of things, these seem like incredible luxuries to me. Many people in the world don't have most of these. I don't want to let myself believe they're not luxurious and that instead, I need a $150k car (for example) to feel like I've made it.
My experience with Apple's support is abysmal. They left me without a working product for something like 6 months despite the product being faulty (bricked Studio Display). Years prior to that I had issues with a MacBook Pro. That also took way too long to repair (6 weeks), and I was treated as though I broke it rather than the hardware failed due to manufacturing defects. Very much a 'guilty until proven innocent' customer support experience.
I hope that's not the typical experience, but it's certainly mine.
The Disappearance of Rituals - Byung-Chul Han
Outlive - Peter Attia (This felt like a complete waste of attention)
An Emotional Education - School of Life/Alain de Botton
The Story of Your Life and Others - Ted Chiang
Nausicaä of the Valley of the Wind - Hayao Miyazaki
Plants from Test Tubes - Lydiane Kyte; John Kleyn; Holly Scoggins; Mark Bridgen
Some biography I've forgotten
reply