This is a creepy station, green filters notwithstanding. The article repeats this statement that I've seen elsewhere and always found pretty questionable - that 800 people have died on Tanigawa. I've no idea where this data comes from but it seems very unlikely. If you just want to get to the top by the simplest route then it's a non-technical day hike up a not-very-high mountain. It's also a multi-pitch rock climbing area but I'd struggle to imagine that 800 rock climbers have killed themselves there over the past 100 or so years.
Wikipedia also says the same thing, both in English and in Japanese, and in both languages uses this report[1] as the source. This in turn sources a medical journal and a report by a mountaineering club. I don't know Japanese and can't really check whether these are reliable sources that actually exist. Essentially what this report says is that after WWII, particularly in the late 50s and the 60s, there were lots of climbers and unsafe routes, causing a large number of fatalaties. Afterwards there's a sharp decrease, though still pretty significant numbers.
I've climbed routes in ichinokura a few times. It is impressive, and some of them are quite poorly protected. But 800 climbers seems like an exceedingly high number, and that report seems quite vague and unsubstantiated, even if it does come from the government. So I remain sceptical.
I've been wondering about this for some time. My initial assumption was that would be that LLMs will ultimately be the death of typed languages, because type systems are there to help programmers not make obvious mistakes, and near-perfect LLMs would almost never make obvious mistakes. So in a world of near-perfect LLMs, a type system is just adding pointless overhead.
In this current world of quite imperfect LLMs, I agree with the OP, though. I also wonder whether, even if LLMs improve, we will be able to use type systems not exactly for their original purpose but more as a way of establishing that the generated code is really doing what we want it to, something similar to formal verification.
It's interesting to think about what is 'optimal' when discussing LLMs; considering that the cost is per-token. So assembly would be far from optimal as it is not exactly a succinct language... A lot of common operations are repetitive and require many operations; a more abstract, higher level language might actually be inherently more succinct.
It's not just that humans aren't good at thinking in assembly language or binary, but the operations are much more granular and so it requires a lot of operations to do express something as simple as a for-loop or a function call.
I think the perfect AI might actually come up with a language closer to Python or JavaScript.
I think that this does fill a niche. You can still compile to bash outside of this austere environment, and run the scripts within it. And python isn't very ergonomic for running external shell commands (or, say accessing environment variables), the syntax for doing so in amber looks much neater.
The people directly managing the investment are unlikely to also be holding REITs, so your assumption is valid. I think it's basically that:
- The people who care about company profit are the asset managers, who will tend to implement their ideas by selling/buying shares, rather than trying to encourage a given company's management towards better practice
- Corporate governance itself is therefore usually outsourced to proxy voting companies, who are quite conservatively-minded (and spread quite thin) and so won't tend to micro-manage, they'll assume that profit maximization is the job of management
- The only thing the proxy voting companies will tend to have a say on is ESG-related, and WFH doesn't really fit into that
I'm using a System76 Lemur pro. I've had it more than two years and I only have good things to say about it, some of which are:
- The battery life started off as spectacular and is still not bad, I get about 5 hours out of it for general use, including compiling code
- When it arrived it had a dead pixel in the middle of the screen. They replaced it in a very low-fuss way, sending the replacement immediately (before I'd sent back the original, so that I didn't have any downtime)
- The spec is well-suited for coding/general linux work. It doesn't have a fancy graphics card or a hi-res screen, but I don't want those things,they add weight and cost and decrease battery life.
- I installed NixOS from the get-go so didn't ever experiment with PopOS so nothing really to say there
I think this is exactly right. Function names actually fulfil the role of documentation really well. I personally tend to make them long and quite verbose, like
I'm sure that somebody has thought this through more fully than myself, but the impression I have is that for software, the benevolent dictator model works best. Python and Javascript occupy adjacent places in the programming language firmament, but the Python language (with van Rossum having fairly tight control over it), although bloating somewhat over time, has still ended up quite a lot more elegant than Javascript.
Ironically, Guido got dethroned precisely because python became too popular and “you can’t please all of the people all of the time” so he just walked away.
Now they have committee meetings to decide if an idea is good enough to form a committee to discuss if a committee should be formed to discuss the idea — though, probably not exactly like that…
Modern python is not more elegant than modern JS, I disagree (I’ve been coding in both for over 15 years).
Python has a good degree of elegance to it, and it does have less warts due to its less stringent backwards compatibility requirements. But JS is very elegant, and better at it than python thanks to python’s shitty lambdas vs js anonymous functions.
Maybe a silly question, but if js is such a complete language, why are there so many js frameworks being developed all the time, all seemingly with the goal of making it easier to do fairly basic tasks with js?
Elegance and completeness are two different things. But to answer your question anyway, I would say a framework's goals are more specific than the language's.
For example, Python serves both the data science community and the embedded community. The two have wildly different goals, and thus, different frameworks to achieve "fairly basic tasks [for their domain]".
JS serves so many different communities/domains, which is why there are so many frameworks. Larger audience, with even more different needs. The fact it can serve so many different audiences is a testament to its elegance.
There’s nothing elegant about continuously accreting features.
If JavaScript were limited to The Good Parts I could say it’s elegant. As it stands I’d describe it as more akin to Frankenstein’s monster but riddled with tumors.
