|
It's probably already done by many external contractors with high security clearances (to be able to do the final integration with the planes systems at the end).
CI/CD = Continuous Impediment/Continuous Despair
|
|
|
|
|
PaltryProgrammer wrote: can be built by private engineers at much lower cost than .4 Million
I don't believe that's possible, private engineers have no clout, and therefore no chance, in that type of business.
"the debugger doesn't tell me anything because this code compiles just fine" - random QA comment
"Facebook is where you tell lies to your friends. Twitter is where you tell the truth to strangers." - chriselst
"I don't drink any more... then again, I don't drink any less." - Mike Mullikins uncle
|
|
|
|
|
You're ignoring development costs, materials, and manufacturing. Development costs were at least in the tens of millions. Materials are probably a lot more exotic than you think to accommodate requirements for durability, weight, pilot safety, and resistance to environmental conditions (electronic warfare especially). As someone else mentioned, these are built in the hundreds, so manufacturing economy of scale doesn't really come into play. Precision requires the same kind of high-cost CNC machining (and the related programming) as used in consumer electronics, but without a lot of the automation. You also have stringent quality assurance testing that must be performed. A broken helmet at 40,000 feet and Mach 1.2 could kill the pilot.
Your argument is the same one that William Proxmire used to dismantle the U.S. manned space program, and has the same fallacies.
Software Zen: delete this;
|
|
|
|
|
when you use this new feature it create plenty of warnings... lulling us into a false sense of compiler enforced code validity.. but it's all a lie!
This simple code snippet below trick the compiler and create doubly unexpected null exception 
var list = new List<string>();
IList ilist = list;
ilist.Add(null);
ilist.Add("hello");
list.Add("hello");
Console.WriteLine(list[0].Length);
Console.WriteLine(list[1].Length);
EDIT
I guess perhaps I would simply have to change my expectation and get used to it....
But it started with a disappointment...
This is only compiler sugar coating, no runtime change.
EDIT2
I had too high and unrealistic expectation from all the buzz....
Look there is even a list of Known Pitfalls on the concept MSDN page.
I guess backward compatibility is a bitch...
My top #1 annoying null from that MSDN page:
var array = new string[10];
all the strings in this array are null, obviously. But the compiler will act as if it didn't know! 
modified 30-Sep-21 1:31am.
|
|
|
|
|
Super Lloyd wrote: all the strings in this array are null, obviously
Too bad they aren't initialized (as a string) to "0xBAADF00D"!
|
|
|
|
|
Or 0xDEADBEEF. 
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
All sense of compiler-enforced code validity is an illusion. Even fixing compiling errors doesn't provide validity guarantee. Warnings, long before nullable was a thing, served the same purpose. You can fix a type mismatch warning by reading the code, understanding what it's doing, how it's doing what it's doing and why it's doing it this way, or you just stick a cast in it and hope for it to pass the test suite. Which it usually does, but since the test suite doesn't catch all edge cases customers may come up with, it will blow up later. Muuuuch later.
Nullable is really just the same pill in a new bottle. That pill always comes with "... but you still gotta kinda know what you're doing, not assuming the compiler to be omniscent".
|
|
|
|
|
Not sure what you're expecting here. IList has no knowledge of the type of its elements. Both the parameter to Add and the returned element of the indexer are typed as object? to be as wide as possible. You'd have the same problem here:
var lst = new List<int>();
IList ilist = lst;
ilist.Add("Lorem ipsum");
|
|
|
|
|
I expect what's the hype was about. I.e. for nullable reference to be the best thing since sliced bread!
|
|
|
|
|
Nullables can be extremely useful and the dotNet framework has done a good job of implementing them consistently. The reality is that it is extremely difficult, and I suspect impossible (thank you Kurt Gödel for the proof that no formal system is complete) for a static analysis to find all errors in code. This is why we debug code at runtime.
Bottom line, don't depend on any compiler to alert you to runtime bugs.
|
|
|
|
|
I would expect code that casts a List<string> to a IList to manage nulls.
If I just want to return a simpler interface, I'd cast to IList<string>.
|
|
|
|
|
Wow, really interesting example. My personal experience has been really positive with Null Reference Types, and it's caught many real world issues long before production, but good to have a cold reminder.
I guess I normally consider the point of NRT for me is that it increases the chance that the compiler at least puts the developer to the decision, so if it's a mistake it's a conscious one. This is a good example where that can't be guaranteed.
Let me try a counter argument to the IList example, if not only for my own sanity and shrinking NRT world view... So, the null was permitted, not because it was added to a collection of non-nullable strings, but effectively it was added to a list of explicitly nullable objects. Yes, explicitly is not so explicit yet, but hear me out. If you now try and pluck that null object out, and use it where a null is not permitted, I believe the compiler will realise, as your IList is actually IList<object?>, so the explicit typing is actually there, and so the compiler will save you at the last minute before the null actually becomes a problem. Based on this I think the behaviour we see is ok and probably by design.
string s = ilist[0];
As for the array, though...? B*gger, that's scary. Maybe a bug? Weirdly it recognises array as being string[]? after the line it's declared on, but then still does not generate a warning when reading that string? back into a new string.
EDIT: Just realised your Console.Writeline bits do demonstrate you reading it out. Are there any examples that don't involve array [] syntax? Maybe it's a bug worth raising?
modified 6-Oct-21 16:48pm.
|
|
|
|
|
|
|
At least they offer free returns! 
Get me coffee and no one gets hurt!
|
|
|
|
|
Only 5 left in stock...better get it before they're gone.
The less you need, the more you have.
Even a blind squirrel gets a nut...occasionally.
JaxCoder.com
|
|
|
|
|
If it's a real color calibrated screen (for photo or video) , it can add up quickly.
CI/CD = Continuous Impediment/Continuous Despair
|
|
|
|
|
Maximilien wrote: If it's a real color calibrated screen (for photo or video) , it can add up quickly.
Thanks for mentioning that. I was curious where the cost was coming from.
|
|
|
|
|
If you get a 2 TB hard drive, instead of 1 TB, the price drops to $2949!
|
|
|
|
|
But doing that also changes the processor. Probably changes other options as well, but I didn't look too closely
|
|
|
|
|
Aside from the parts, a big part of that price is probably this: Delta E<1, Pantone Validated. That means the color differential between pixels/colors is imperceptible to the human eye (perfect color is dE=0; the minimum perceptible differential is 1). Pantone Validated means it has exceptional color accuracy according to the Pantone Matching System of colors.
I'm not super informed on the details of all this but in general any high-end displays for artists are super expensive from what I've seen.
|
|
|
|
|
That's got to be a mistake, because if you choose the 4 TB hard drive, the price goes down to $4,999.
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
Select the 4TB hard-disk and the display goes back to 17" FHD
15.6" 4K UHD is only possible with 1TB
|
|
|
|
|
I still mourn my beloved EeePC 701. It still runs, but by today standards it's more crawling than running.
GCS d--(d-) s-/++ a C++++ U+++ P- L+@ E-- W++ N+ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- r+++ y+++* Weapons extension: ma- k++ F+2 X
|
|
|
|
|
The price comes from the screen and GPU. The Nvidia Quadro series of GPU's are specifically designed for video rendering, both real-time and post. The CPU and memory speed and amount of memory contribute, but it's primarily the GPU, screen, and availability.
NVIDIA QUADRO RTX 6000 (Desktop Version)[^]
[EDIT]
For spelling, or my lack there of. 
"When you are dead, you won't even know that you are dead. It's a pain only felt by others; same thing when you are stupid."
Ignorant - An individual without knowledge, but is willing to learn.
Stupid - An individual without knowledge and is incapable of learning.
Idiot - An individual without knowledge and allows social media to do the thinking for them.
modified 19-Nov-21 21:01pm.
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
