Slashdot Mirror
Who's Responsible For Accidents Caused By Open Source Self-Driving Car Software? (ieee.org)
Here's the problem. "You could download Comma.ai's new open-source Python code from Github, grab the necessary hardware, and follow the company's instructions to add semi-autonomous capabilities to specific Acura and Honda model cars (with more vehicles to follow)," writes IEEE Spectrum. But then who's legally responsible if there's an accident?
Long-time Slashdot reader Registered Coward v2 writes:
While many legal experts agree OSS is "buyer beware" and that Comma.ai and its CEO Georg Hotz would not be liable, it's a gray area in the law. The software is release under the MIT OSS license and the Read Me contains the disclaimer "This is alpha-quality software for research purposes only... You are responsible for complying with local laws and regulatons." The U.S. Supreme Court, in a series of court cases in the 1990s, ruled open source code as free speech protected under the First Amendment of the U.S. Constitution.
The question is does that release the author(s) from liability. The EU has no EU wide rules on liability in such cases. One open question is even if the person who used the software could not sue, a third party injured by it might be able to since they are not a party to the license agreement.
An EFF attorney told HotHardware "Prosecutors and plaintiffs often urge courts to disregard traditional First Amendment protections in the case of software." But not everyone agrees. "Most legal experts that spoke with IEEE Spectrum -- and Hotz himself -- believe that if you use the company's code and something goes wrong, then it isn't liable for damages. You are."
The question is does that release the author(s) from liability. The EU has no EU wide rules on liability in such cases. One open question is even if the person who used the software could not sue, a third party injured by it might be able to since they are not a party to the license agreement.
An EFF attorney told HotHardware "Prosecutors and plaintiffs often urge courts to disregard traditional First Amendment protections in the case of software." But not everyone agrees. "Most legal experts that spoke with IEEE Spectrum -- and Hotz himself -- believe that if you use the company's code and something goes wrong, then it isn't liable for damages. You are."
It's coming anyway - just like bridge builders and other REAL engineers.
No, software engineering is not just like bridge building. Only simple software can be proven correct - bridge builders have equations they can use to verify their work.
My God, it's Full of Source!
OUTSIDE_IP=$(dig +short my.ip @outsideip.net)
the renter of the car who you don't own is! Even when it's just an auto taxi I hope you don't drop the soap after the auto taxi BSOD and kills some one.
Software liability is not new. Its use in automobiles is.
If you download, compile (or trust some 3rd party build), and use you are responsible.
If your self driving car, using open source software, is in an accident, you are responsible. There is no responsible 3rd party.
This is old law.
This is the meaning of use at your own risk.
Accept it, or don't use it.
Jesus I don't even know where to get started with this.
Docker, Python, or non-RTOS.
I clicked on the link hoping to see maybe some Simulink model that compiled to a XPC or other embedded hardware. How is linux supposed to know to ignore the ethernet driver and concentrate on running the steering wheel?
Who is going to be responsible for it, open source or not.
Laws are rules for the court, but merely a bottom bar to hit for life. Think beyond laws in your actions always.
Sure, the store may go after Joe the installer, but that is their problem, not yours and the reason you didn't hire Joe directly. See subrogation.
I have to agree here.
If I buy a part for my car and the part's manufacturer claims that it complies with some ASE or similar standard, then if the part fails I might have a legal case (e.g., if I can prove negligence in the design or manufacture, or something that the established case law will respect). However, if I buy a part off a guy who makes them in his tool shed and hey tells me "hey, I'm not sure that this thing won't explode when apply the brake," then I am pretty sure I have no recourse whatsoever.
How is software different? If the manufacturer warrants it, then it should work as it is represented and if it fails then there is a discussion to be had. If the manufacturer disclaims warranty and it breaks (and the applicable laws don't override that; you know that in some jurisdictions that there are laws that still hold the maker or seller responsible to a degree for things they make or sell?) then I don't have a legal case.
Of course, even professionally produced commercial software normally has a EULA with a clause that reads something like "the manufacturer provides no warranty of merchantability or fitness for a particular purpose and shall not be liable for losses arising from blah, blah, blah..." If you are NASA and paying your contractors (an enormous amount of money) to mathematically prove their software correct then you might get a "yup, we certify that this software will work as designed," otherwise you have no such assurance.
If you drive a car over a carload of nuns, you're liable. What's new here?
Don't take life too seriously; it isn't permanent.
Neither bridge building nor software engineering have mathematically proven models. You can approximate and calculate a lot of it based on years of construction but you still have to have common sense and experience.
The reason we have shitty software is because nobody typically dies when something goes wrong (and in the cases where it does, the instances are so rare the companies behind them often don't care enough). Bridges on the other hand are not nearly as lean and cost effective as they theoretically could be because nobody wants to take that risk, a bridge collapsing is severely more expensive than someone's heart rate monitor halting so if you need to build the largest bridge in the world, you pay the freaking engineers $1M/year in salary, if you need to compete to sell the cheapest heart rate monitor in the world, you get some Indian guy barely out of high school to do it for $1k.
It's why planes (until the Boeing 777X/AirBus A350 at least) have multiple "computer systems" (which are really purpose-built programmable machines) on physically separated networks but medical equipment runs Windows XP with a public IPv4 address on the Internet. 1 person that's already halfway in the casket is an acceptable risk, 100 people dying because of the same sloppy software practices would be a tragedy for the company involved.
Custom electronics and digital signage for your business: www.evcircuits.com
I'd advocate for liability for the companies that employ the engineers. In construction, the engineers are often not directly responsible unless you can prove intent, although they may lose a license in cases of severe incompetence. The construction company may be on the line for some of the construction costs, but often the governments involved ends up paying for those sorts of losses. In most cases however, it's not necessarily the engineers but the construction company and/or their subcontractors trying to squeeze out a few dollars in the process that are the problem.
Custom electronics and digital signage for your business: www.evcircuits.com
If you package something for sale, you are responsible. Here's a box filled with stuff for 49.99, oops the box exploded one or 10 times. The boxing vendor is responsible, regardless of the interaction that caused it. There is no specific law, but tort law generally plays out that way. A separate boxer? Not that guy's problem but he always has to go to court to be found, not at fault. Nothing here about software liability applies excepting between the packaging vendor and the development team. Will we see the US make a rational decision to this end? No. Will it result in this chain of responsibility eventually, yes.
Often wrong but never in doubt.
I am Jack9.
Everyone knows me.
It's easy with systemd. You just have to write it in the form of a Sanskrit poem.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
Python is single-threaded and thus it's speed and results should be predictable. Not sure whether Python would still run on a decent real-time processor though (x86 has not been in a long time) because it's overhead would be enormous.
Custom electronics and digital signage for your business: www.evcircuits.com
Wow.. I'm impressed. Almost everything you said it's false!
Python explicitly runs as a single thread (thanks to the GIL partially) and uses time slicing to simulate multi threading.
The is also no such thing as a real time processor. I guess you think you mean a real time os? But I'm guessing the.
And no. Python performance is far far from predictable on any os it commonly runs on.
Nice language for UI development and glue code though.. use it a lot. But most certainly not hard real time.
While you make some good points a counter arguement could be since it is alpha software and they released it knowing that and even potentially admitted it may be flawed they were negligent in releasing it. IIRC, you can't declaim negligence although many Agreements try to do that; the question here is not would the owner of the vehicle be liable but could the software developer also be liable.
I'm a consultant - I convert gibberish into cash-flow.
I don't know much about Python since I don't use it. I know it's single threaded because I tried multithreading some existing code once and gave up.
A well-designed single threaded program should be predictable after compilation, what the hell is it doing that makes it non-deterministic, doing a "sleep rand(1...10)" after every line?
I meant a processor that you can predict it's state after every line, for most small microcontrollers you can easily (even manually) trace every code interaction and predict how much time it takes before you get an answer. Modern x86 practically have their own OS that not only translates the instruction set but also 'does things' like cleanup and optimization which makes it very hard, if not impossible, to predict what will happen and when it will return the next instruction you give.
Custom electronics and digital signage for your business: www.evcircuits.com
Parent is 100% wrong. The reason you are typically responsible for open source software is because the license comes with a disclaimer of warranty and of liability. For example, the GPL license says:
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
This does not prevent a company from selling you a warranty for a fee. e.g. Enterprise software customers get a warranty, because they pay for it. If you're buying a self driving car, insist on a warranty.
tl;dr: Parent is wrong; do not buy a self-driving car that doesn't come with a warranty.
One example is garbage collection.
Why is there an "insightful" mod and why isn't it "-1"? If I wanted insight, I wouldn't be reading
Whoever the courts/governments decide is responsible on a case by case basis, or course!
If someone publishes some bomb making recipe, would that person be free of liability? You can's simple slap EULA and license agreements to dodge the liability. If the bomb recipe you provide or the software you provide enables a person to do something that they would not have been able to otherwise, are you completely free of liability?
sed -e 's/Chuck Norris/Rajnikant/g' joke > fact
It will be a replacement at some point. Avoiding accidents will not be the driver's job, but my expectation is that it will remain his responsibility; there's a difference. His insurance will have to cover it. Depending on your country's legislation of course, in some places insurance is tied to the driver, but over here it's tied to the owner of the car.
Any insurance company will take a long and hard look at the risk involved. What are the odds of an accident happening with any particular flavour of autopilot? If there is an accident, is there a manufacturer who can be held responsible? In the case of OSS, there is no entity to sue so insurance companies may well demand a much higher insurance premium for cars with OSS autopilots, unless statistics show that this autopilot is extremely safe. But in any case I will make this prediction: it won;t be too long before insurance premiums for human-driven cars will exceed those of self driving ones.
If construction was anything like programming, an incorrectly fitted lock would bring down the entire building...
This begs the question (assumes it and ignores it): When a NON-open-source software program is involved in an accident, the responsibility is that of the manufacturer.
That is not true according to current cases dealing specifically with Tesla.
A better question isn't "Hey if an open-source independent vehicle software program causes a crash, who's responsible" but rather: 'Who is responsible when software causes a crash" or better yet "How can people be responsible for their own behavior even if relying on a tool?"
E
That's not true. My neighbor's dog "borrowed" his car one Sunday last year and ran it into the front of the local pet store. Made off with two bags of premium dog food, three cats and $340 from the cash register. Neither one of them got charged.
Actually, It's me. Sorry in advance for all the dead people, all of that is my fault. Even the ones ain't died quite yet. Although I do feel badly, I do. Again, sorry.
Just last year an 18 wheeler made a careless lane change and scraped the bumper of my wife's car. (It was a peak hour traffic at 4 mph or so). It was the trucking company's insurance that paid for the 500$ damage.
sed -e 's/Chuck Norris/Rajnikant/g' joke > fact
So what you are saying is, al queda and ISIS have to simply open source their bomb making recipes and release it under GPL, then they will be free of liability. Right?
sed -e 's/Chuck Norris/Rajnikant/g' joke > fact
God is responsible, die suckers.
That's the problem, the "driver is responsible" model is useless. Babysitting a self driving vehicle is no easier than just driving it. The untapped resource with self driving vehicles are the state and federal DOT's. With fairly cheap roadside infrastructure (including cameras, centimeter accurate local positioning systems, vehicle location recording and broadcast) and a certification process for what software must do to drive a car, responsibility for the whole system becomes distributed over companies AND state and federal governments, and incremental changes can be made publicly over time for safety. No CEO gets to be Tony Stark and single handedly take all the credit for the system, but also no one takes all the blame when things go wrong, and it can move forward openly with public input.
-The art of programming is the pursuit of absolute simplicity.
This is one of my arguments about so-called 'self driving cars': The manufacturer is technically driving it if it's in self-driving mode, but just like so many of them, they'll dodge responsibility one way or the other if someone gets killed, and in the end there'll be no justice at all. It'll get tied up in the civil court system for years, or in some sort of arbitration, and in the end you'll either get nothing or some paltry chunk of change, and meanwhile a person is dead, all because of some shitty technology that was rushed to market that doesn't even have the cognitive ability of a smart dog. These so-called 'autonomous/self driving cars' are not going to be the panacea that some of you think it's going to be, we're just going to trade human error behind the wheel for human error in the development division of an auto manufacturer, or human error in the marketing department for rushing it to market before it was really safe to do so. All I can say is I'm not going to be the one strapped into a car seat with no controls whatsoever to stop the gods-be-damned thing when it goes haywire and kills me, and I have nothing but feelings of horror for whoever does, and deep sympathy for whoever the poor bugger leaves behind them.
Oh, and by the way? The way I think this should be handled legally-speaking, since it's obvious we'll be subjected to these gods-be-damned things regardless, is the same way aircraft mechanics are treated, legally: If a plane they worked on crashes and people die, and the cause of the crash is proven to be a mechanical failure that's the responsibility of the mechanic that worked on it, he is arrested and tried for murder. A so-called 'self-driving car' kills someone? The programmer(s) responsible for not doing their job correctly get thrown in jail charged with murder. Oh and before any of you give me shit for this? You all make a big point about how 'self driving cars will save lives'; well if they TAKE a life then some HUMAN has to be held criminally responsible for it, plain and simple. Otherwise you're just hypocrites.
So what you are saying is, al queda and ISIS have to simply open source their bomb making recipes and release it under GPL, then they will be free of liability. Right?
Nah, they don't even need to do that. Publishing is not a problem in most of the world. Even building and posessing them isn't a problem if you follow the law and basic safety rules. People and companies use explosives that could be used as bombs all the time.
If you're talking about publication only, The Anarchist Cookbook, first published back in 1971, describes how to make all kinds of bombs, explosives, and poisons, as well as assorted drugs like LSD. It is still in print, and pirated versions are available online. While it is banned in a few nations, in the US and several other countries it is protected under free speech rules.
Many groups use high explosives and bombs all the time. They just do it responsibly and follow the laws about keeping safe distances and notifying police, etc. Movie makers TV shows (like Mythbusters) build high explosives all the time. They generally need to take them to the bomb range and have supervised explosions, or have various permits in place. But even so, bomb-making recipes aren't a problem, neither is building high explosives when you follow the basic safety rules and laws.
Possessing a book about something dangerous typically isn't a crime in itself. Otherwise anyone who majors in chemistry or biology should be jailed. I saw a sign once saying: Welcome to Organic Chemistry where questions like 'where do you keep your chloroform?' are not suspicious. Not just chemistry and biology classes, but anybody learning about bomb disposal would need to study bombs, researchers in the industry need to write about the topics and share with other experts, and so on. Even fireworks manufacturers would be in serious trouble if they couldn't share documents or buy and sell explosive parts.
//TODO: Think of witty sig statement
How much for death how much for loss of limb
The letter of the law is sort of unimportant. If you thought Ford was going to be responsible, then it is not your understanding of law I would call into question first, but your basic common sense. A car would practically have to cost twice as much, if the manufacturer was responsible for all accidents and deaths it caused.
Troll is not a replacement for I disagree.
In this particular case, since it is described as "alpha quality" then the owner and/or person who installed the software is liable. The question should be, "If there were OSS of stable quality properly installed on a compatible vehicle in excellent condition (so that neither the vehicle nor the installation procedure can be considered as "at fault"), who would be considered liable in an accident that can't be blamed on local conditions (weather, etc.) or the other party?
Where is the 'Cowboy Neal' option?
Cowboy Neal is your co-pilot?
Pain is merely failure leaving the body
The owner of the vehicle is responsible for ensuring his vehicle is safe to use. If he modifies it, by installing some untested software, he is most certainly responsible for the consequences if he then injures someone. And if the disclaimers are clear enough, his chances of successfully suing the software developer are slim.
The sad thing is that, as with the Tesla, you know some idiots will install this and go on to kill people - hopefully just themselves. After that I wouldn't be surprised to see the software developer sued claiming the warnings on the software were just not clear enough. Or even the car manufacturer, for allowing the vehicle to be so modified in the first place...
Huge chunks of Intel processors are formally verified now. Intel increased usage of formal verification as a result of the fdiv bug.
"First they came for the slanderers and i said nothing."
> The reason we have shitty software is because nobody typically dies when something goes wrong
The reason we have shitty software is because nobody wants to pay for having well tested software. The costs would be factors higher.
Let's assume you're talking about CPython, because Python is a language, not an implementation.
No it doesn't. CPython supports threading.
No it doesn't. CPython uses OS threads, it does not do its own time slicing.
What you're thinking about is the GIL, which ensures that only one (real) thread is running *inside the interpreter* at any one point. You can spawn multiple CPython threads and they will be *real* threads scheduled by the OS. However, they will mutex each other out of running the interpreter at once in multiple threads. You can make blocking OS calls, or calls out to C code that is thread-safe, and they will run concurrently on multiple cores. No time-slicing.
CPython has perfectly real threads. It just isn't suitable for concurrent computation in pure Python code due to the GIL.
There is, however, such a thing as a platform unsuitable for real-time processing. And commodity x86 platforms have been unsuitable for real-time processing ever since BIOSes decided to schedule code behind your back in SMM code without the OS being able to do anything about it. You need a very special BIOS to make sure this doesn't happen.
... which Python only uses for auxiliary purposes. Just call gc.disable(). Poof, no garbage collection. No memory leaks as long as you do not use data structures with reference cycles, either.
I'm an independent contractor, and I always shift the liability to my client. They are the ones making the big bucks when the project is a success, so they should be the ones covering the damages if something fails.
Many software licenses include similar like this:
"The software is provided "As is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. "
This is from the MIT license, I'm sure other open-source licenses have a similar clause. It basically tells you that using this software, is at your own risk.
...You are over-qualified and under-paid. If we give you a raise, we will break the cosmic balance of the universe.
The principle is that the state are responsible for ensuring the safety of the vehicle So if a vehicle have been certified safe by the authorities they take responsibility for the safety. On the other hand if there is no regulations regarding software used in cars or that software is proprietary then the manufaturer needs to take responsibility.
In the case of OpenSource there is definitely a possibility that the owner might be responsible. But American law is funny so it could go both ways.
So the driver is responsible. But since the human isn't driving the self-driving car, the car itself is responsible?
Its your fault for getting in the auto pilot death machine and running over those babies.
if I buy a part off a guy who makes them in his tool shed and hey tells me "hey, I'm not sure that this thing won't explode when apply the brake," then I am pretty sure I have no recourse whatsoever.
There are limits to this: if the seller in question made the brake pads out of plastic explosive I'm pretty sure the police will soon be knocking on his door. Putting a disclaimer on things does not magically allow you to get away with anything and some countries like the EU have mandatory minimum guarantees.
However in this case the software is not sold but given away so there is no sale which probably keeps the author protected unless they put something deliberately bad in the code.
It is about who declares to take responsiblity.
Someone (i.e. a auto company) can create an open software, release a signed version and take the resposiblity (to a defined degree). If they don't, nobody actually needs to software, as you cannot use it without driving yourself, or your car is driving illegally.
If you now use this software, the liability is clear. When you start modifying it, it becomes interesting. Because either you have the full liability for the selfdriving part yourself (which probably means some accreditation to take liability, i.e. by having a reinsurance), or falling back to manual driving liability, which means you cannot legally do something you aren't allowed when driving without autopilot.
The point is, that the accreditation is important, as the self driving part may harm other people, not just you. So you should really know what you're doing, why and have someone watching you.
Another question is, are you only liable for things resulting from your modifications or for everything which happens with a modified version? Who can decide, if your part, another part or the whole package caused the accident?
This said, the open source is a great idea, while the normal person should not be allowed to run a system with (big?) modifications.
Another interesting consideration: Is a signed source enough? What if the accident happens because of a compiler bug? Does the compiler need a certification for building car firmware or does the firmware builder need to assert, that he checked the binary to have no bugs, which aren't visible from the source?
"who's legally responsible if there's an accident?"
Nobody is liable going by the Microsoft Windows 10 EULA. Indeed the license specifically bars you from sueing them in a court of law and even then you can only get back what you paid for the software or $50.
"One open question is even if the person who used the software could not sue, a third party injured by it might be able to since they are not a party to the license agreement."
The third party can't sue the first party precicely because the first party has no contractual obligations to the third party. Shame on you slashdot for allowing this forum to be used to insert Open source FUD into the blogosphere.
The AI left plenty of white space. But other drivers kept pulling into it.
Have gnu, will travel.
I know it's single threaded because I tried multithreading some existing code once and gave up.
Oh well if you tried and gave up then it must be single-threaded then right? In fact you can do multi-threading in Python - regardless of whether you gave up trying or not - and generally time-slicing is used to run the different threads "concurrently" on implementations that rely on the global interpreter lock.
Much like pretty much every open source license the one here is no different. It's open source, you have the freedom to do whatever you like with it, but you are the one who assumes responsibility for it too.
Copyright (c) 2016, Comma.ai, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
https://raw.githubusercontent.com/commaai/openpilot/master/LICENSE.openpilot
It's coming anyway - just like bridge builders and other REAL engineers.
So what's that got to do with Open Source? They will either continue releasing with licenses that explicitly avoid any claims for warranty or liability just like in the case we are talking about right here or it will just kill Open Source because nobody wants to open themselves up to that sort of legal backlash just to release OSS.
Python IS single-threaded, multi-threading is a big hack on Python and usually (at least a few years ago) came with big warning letters not to use unless you absolutely knew what you were doing.
Time slicing is not multi-threading, can it allocate a process to a particular CPU or guarantee it's still running on the same CPU when I call back? I think that's the same issue Rust has.
Custom electronics and digital signage for your business: www.evcircuits.com
Python IS single-threaded, multi-threading is a big hack on Python and usually (at least a few years ago) came with big warning letters not to use unless you absolutely knew what you were doing.
No, the Python interpreter is single-threaded, that doesn't meant that things like I/O operations have to block everything else, in fact anything that isn't being interpreted can be done outside of the interpreter lock.
Time slicing is not multi-threading
I didn't say it was, I said that is how (on some Python implementations) concurrency is implemented, much like the way you can multi-task and run multi-threaded processes on a single core CPU.
I'd advocate for liability for the companies that employ the engineers. In construction, the engineers are often not directly responsible unless you can prove intent, although they may lose a license in cases of severe incompetence. The construction company may be on the line for some of the construction costs, but often the governments involved ends up paying for those sorts of losses. In most cases however, it's not necessarily the engineers but the construction company and/or their subcontractors trying to squeeze out a few dollars in the process that are the problem.
AFAIK, it doesn't take *severe* incompetence for structural/mechanical/civil/electrical Engineers to be sanctioned or potentially lose their license. Simply not following standard engineering practice or signing off something which is outside your area of practice (which often implies culpable negligence) is enough.
Companies can't simply hire "engineers" to perform engineering in most fields, they often have to hire Engineering companies whose principals are actually licensed Engineers, or if they employ chief Engineers who are not principals in the company, these employees have to at least have signature authority to sign off on designs and/or specifications (and any waivers the eventually occur). It is the Engineers who put their licenses on the line when they sign-off on specifications.
Of course if the construction company doesn't follow the engineering specs, or if they employ an "technician" that signs off on a waiver of the approved spec, the construction company is generally fully responsible and the Engineer or Engineering company is off the hook. In reality on any project there are many waivers and so-called "equivalent-substitutions" used by contractors and sub-contractors that may meet the letter original spec but are inferior in some way which causes a problem. This is generally when the lawyers come out.