I wonder how much of this is because (IME anyway) Tesla drivers are not very good. With all that tech it's easy to get distracted (there's literally a giant tablet looking thing for a console). It's also easy to think all the bells and whistles will do things for you so drivers are paying less attention because the car will beep and holler at them if things are going awry (except by that point it's too late).
Whats the temperament of the driver. Certain brands attract hot heads who will drive recklessly. I was kind of expecting more sports cars in the top 5. 2/5 is still a good score.
Given the amount of SUVs as well, no matter how safe you make a small car, if an SUV rams you, it is just not going to end well for the smaller.
Tesla drivers are young men with big wallets, stereotypically. That demographic is not known for their carefulness in traffic, or in any other matter. I'm sure that simple confounding factor is enough to explain the excessive fatality rate of Tesla cars.
This is how I made a better version of the nhl.com site [1] that has a better UI (you can see scores/schedules much more easily), is mobile first, has no ads, and responsiveness built in. I did the same for the AHL [2], and the PWHL [3].
I did a similar thing (improving a site I'm unaffiliated with) with Skill Capped which has videos to improve at League of Legends. My version has a search bar which they still haven't added in 4.5 years.
Funny you would mention that. A few weeks ago, I wrote a Python-based client library [0] for the website kicker.de [1].
It supports the NFL, too:
import asyncio
from kickerde_api_client import Api
from kickerde_api_client.model import LeagueId
api = Api()
query = {'league': LeagueId.NFL, 'season': '2024/25'}
season = asyncio.run(api.league_season(**query))
print(season['longName']) # 'National Football League'
print(season['country']['longName']) # 'USA'
print([
team['shortName']
for team in season['teams'].values()
if team['shortName'].startswith('B')
]) # ['Buffalo', 'Baltimore']
day = season['gamedays'][18]
print(str(day['dateFrom'].date())) # '2025-01-05'
I don't know. I am a woman who does not have those specific experiences. I happily buy stuff at Amazon, chat with relatives and friends on social media, and is active in some subreddits. I do know several harassment issues where I have received unsoliticed dick picks, been (verbally) sexually harassed, and received lots of creepy messages from strangers on the internet.
Sadly, it appears they have discontinued the free plan:
> But anyone who hasn’t created an account by December 31 [2021] at 11:59pm Eastern won’t be able to create an account via our open registration flow. Instead, they’ll need to choose a paid account, or get a Free account through another channel. Read on for details.
> Try to find the answer to "which units are going to be started on next boot?".
Isn't this just `ls /etc/systemd/{user,system,network}//*` (bah HN formatting is messing this up)
Also the other states:
> Speaking of which, why is systemctl daemon-reload even a thing?
Because configuration changes while things are running. Otherwise we wouldn't need apache2 reload, nginx reload, haproxy reload, etc. Also, according to the man page:
> After the units have been edited, systemd configuration is reloaded (in a way that is equivalent to daemon-reload).
As for systemctl edit, it allows you to add diffs to the unit file. For example, let's say I am using redis and I want to ensure it always restarts (for whatever reason). Rather than manually editing the unit file (which will have issues if an upstream change happens), I can simply use systemctl edit to add a diff for my change. This way I can still maintain compatibility with the upstream unit file instead of having to deal with potential conflicts. It's not so much babysitting the user as it is a potentially better experience.
> Isn't this just `ls /etc/systemd/{user,system,network}//*` (bah HN formatting is messing this up)
Nope.
There are many virtual units for which there are no files. One example is the on-demand getty units. There are two for "plymouth" boot-splash stuff (I see these attempted-and-failed units on archlinux where plymouth never exists). There's some autofs thing. There's auditd.
I'm actually not booted into linux right now so I'm struggling to remember the specifics... but if you also count all the simple mounts and devices which clutter up the output of "systemd --all" as "units which are not files in /etc/systemd" then the count is around 100.
Couldn't/Shouldn't this be solved with some script that traces the dependencies of units?
I'm not familiar enough with systemd to understand how to trace dependencies and create a complete list of all units that will run at next boot but I expect this to be doable by someone with that expertise.
The resulting dependency diagram may look complex, but consider that there is no equivalent functionality for SysV init scripts despite the fact that they have the same level of inter-dependent complexity.
The complexity of the dependency graph produced by system-analyze is not present in most sysv init systems. That complexity is mostly a reflection of the efforts to make system services boot in parallel. Most sysv init scripts were blocking and executed serially, which is what allowed the simple filename prefixes to be used for ordering.
What to see your entire sysv init, as it will run every single time?
ls -1 /etc/rc3.d/[SK]* /etc/rc.local | xargs -- cat | less
Whether using a dependency system at all for the purpose of ordering and expressing relationships between daemons is the best approach is beyond the scope of this reply, but I just want to say that most modern sysvinit deployments did in fact have service dependencies, through the use of LSB initscript headers that were parsed by insserv(8).
Previously on arch linux I had a list of 7 to 10 services in rc.conf that started serially in less than 2 seconds. That was pretty damn simple. Besides that there was inittab which just had the gettys and the main startup script.
To a Scala veteran, I'm sure that's easy to understand; to someone who's been learning the language (like me) it looks like gibberish.
I've also had to write code like this:
client.post(args).mapTo[Response].map(r => (r.success, r.serverException, r.unhandledException) match {
case (Some(response), None, None) => response
case (None, Some(serverEx), None) => throw serverEx
case (None, None, Some(unhandledEx)) => throw unhandledEx
})
simply because of the underlying api that other co-workers have built. When it takes you longer than 30 seconds to explain how a piece of code works to others, something is wrong.
All that being said, I do like the language; just not the compile times. It's also pretty close to ruby (with which I'm most familiar):
> To a Scala veteran, I'm sure that's easy to understand; to someone who's been learning the language (like me) it looks like gibberish.
Compare what the same code would look like in Ruby; something like (hope I get the syntax right):
def toVector = fold(new Vector()) {|x, y| x :+ y} {|x, y| x ++ y}
Are the extra |x, y|s actually clarifying anything? Or are they just syntactic ceremony? Maybe it's just my scala experience talking, but I think the scala example is clearer; there's very little performance to get in the way, just the meat of what the function's actually doing
(You can think that's a good or bad function to have, but that's a library question, not a language question).
> simply because of the underlying api that other co-workers have built.
You can write bad APIs in any language; with a more sensible one that would look like:
client.post(args).map{
case Success(response) => response
case ServerError(ex) => throw ex
case UnhandledError(ex) => throw ex
}
Explicitly handling the different cases is exactly the kind of debugging advantage I was talking about; it takes up-front effort to distinguish between ServerError and UnhandledError, but the result is code where you can see all the possibilities and know exactly where any given failure might be happening. (And again, the language doesn't force you to do this; you can just write the happy path and allow any kind of exception to happen at any point. But you'll pay the price in debugging, as I have in Python, and as I presume you have in Ruby).
