I think RSpec should provide around(:context)/around(:all). Not because of any particular use case, but simply for API consistency. It's much simpler to tell users "there are 3 kinds of hooks (before, after and around) and each can be used with any of 3 scopes (example, context and suite)". Having some kinds of hooks work with only some kinds of scopes makes the API inconsistent and forces us to add special case code to emit warnings and also write extra documentation for this fact.

I've been thinking of looking into implementing this in rspec-core, primarily to make the API more consistent (e.g. so that you can combine any scope -- example/context/suite -- with any hook type before/after/around).

The globalThis property provides a standard way of accessing the global this value (and hence the global object itself) across environments. Unlike similar properties such as window and self, it's guaranteed to work in window and non-window contexts. In this way, you can access the global object in a consistent manner without having to know which environment the code is being run in.

If this is okay, then it might even be nice if #dig took a block as well as a fallback value: [].dig(1) { 'default' } #=> "default"

Trying to force this one thing to work for everyone is the worst way to do that.

Don’t get me wrong  —  standards are great. Uniformity is bad.

Many non-Greeks adopted Gteek lifestyles, language and habits after the age of Alexander, but the cross-pollination was more frequently cultural than political.

he Romans assimilated far more people into their institutional lives.

dominating its neighbors and then assimilating them into its institutions

By using HTML as the uniform interface, we can separate the interface from the engine.

it also allows for more divergence in how people write there code and where they put their logic, making different svelte codebases potentially even more different due to fewer constraints. This last point is actually something I really value, I read a lot of Svelte code by a lot of different people and broadly speaking things look the same and are in the same places.

“I came to Rust from Haskell, and I feel that Haskell is a very elegant and safe language. The biggest differentiator for me is that there is a greater difference between high-performance code and idiomatic ‘clean’ code in Haskell than in Rust. Most Rust code looks like most other Rust code, even when it performs well. Haskell can become unfamiliar real quick if someone is operating under different libraries and goals from what you are typically doing. Small differences in syntax can result in huge differences in behavior, and Rust has more uniformity on that axis.”

I sought to shut down a startup culture at the school that was resulting in sites built with decidedly unregulated palettes and proportions.

That is to say, a uniformly valid and binding designation is invented for things, and this legislation of language likewise establishes the first laws of truth. For the contrast between truth and lie arises here for the first time.