Ada is far safer than Rust (not in edge case memory allocation problems, but in day to day application programming), and not only existed at the time, it was the industry standard for aviation (for good reason). Entire educational programs and pipelines existed for it.
Boeing and other defense contractors dropped it because C++ programmers were cheaper on paper (not realizing/caring that good C++ engineers were more expensive).
One of my current coworkers used to work on on-board systems for military aircraft. Anecdotally he tells me the critical systems for the ones he worked on were Ada but other systems could be C++.
There were schools of computer science, accredited universities, that taught it heavily (one of the 3 lab intro to programming languages next to c++ and python, and allowed to be used through the entire program at mine). A 1/3 of graduates of some of these places got jobs in it, because they were reliable and well paying jobs.
And then the industry swapped to C++. This was not a DoD mandate, this was companies like boeing trying to pay their engineers 1/3 to 1/2 less by paying for C++ devs (starting salary for ada devs was 90-140k, starting salary for c++ devs was 60-180k according to exit statistics). They of course eventually learned that good C++ devs are actually more expensive than their old Ada ones. Not that they bothered to hire good c++ devs.
The issue that caused this to be voted down is often seen as a memory safety solution (not something I personally 100% agree with, but thats a broad view). And the rest of this release includes other memory safety work. And it was voted down and delayed for apparent political reasons (again not a view I agree with).
So most people will read your view as hypocritical/misinformed.
It could also be read as a straight up attack. Basically, a way of saying “why not follow Rust“ without having to say the word Rust.
I think it was a fair question. As someone who doesn’t follow C++ I really don’t know what else was in the proposal. It’s nice to hear there is memory safety stuff.
The memory-safety-relevant parts of the proposal could be salvaged without keeping contracts more broadly, by saying that the relevant behaviors (like indexing past the end of a std::vector) cause program termination in hardened builds. I'm sure it's more complicated than this but I don't think much more.
More generally, the C++ committee has had a really hard time agreeing on memory-safety stuff because there are a lot of different constituencies with completely different priorities (especially whether they're using it for greenfield vs. legacy vs. something in between), and the incentive is to make proposals sound good to everyone at the expense of actually being coherent.
Perhaps it is, in this case it would be between money and everyone else specifically. Contracts is a pet project of Microsoft and the heavy money parts of the committee. They've basically shouted down the dissenters, hence the effectively unprecedented action of the rubberstamp portion of the process saying they dont think consensus was reached in a kosher way.
No one who developed contracts works for Microsoft. Of the like 20 people who contributed to the feature, 4 of them work for Bloomberg, so you could maybe argue that Bloomberg has a vested interest in the feature, but that's really stretching things.
Support for contracts is fairly broad and spans numerous organizations.
Its a very inside baseball article. Contracts is a proposed C++ language feature for improving programmable assertions of program state. E.g. a better c++ version of C's assert function. That in theory will improve both safety and performance by letting people add more complex assertions (e.g. pre/post conditions) to functions.
> No special harness, or access to models that weren't generally available to everyone were used in the initial bug discovery. I focused on something I had a background in, knew its vulnerability history well, and held a theory that specific bugs lurk within the codebase. This shows that "know your target" is still as applicable as ever, even in the LLM dominated VR age. No model is simply capable of unearthing "all bugs" with simple prompts.
They used a public model as a research assistant and a code assistant. They guided it with expert deep knowledge of the project. OpenAI did not lead this, ChatGPT was not instrumental in this.
It is perhaps at best to say OpenAI made it possible to find the bug more quickly. And on the double edged sword, also made it easier for it to be exploited days ahead of release. So I agree with the original commentator, did they on the balance actually do anything good here?
> This shows that "know your target" is still as applicable as ever,
totally. I spent yesterday trying to get an AI to make a test case for a very specific bug I had. It kept telling me that it had it. When I could clearly trace thru the code and see it did not. After about 5-10 rounds of that I just wrote the test myself. But at least AI helped with all of the dumb cruft that went around it.
But if I did not know the domain I may have easily just said 'yep looks good'. AI on the other hand saved me at least 3-4 hours of writing all of the scaffolding that made it easier for me to check. In the end the bug had nothing to do with the test. AI did not find that. I went back point by point of what changed in the code and found where I had messed something 2 weeks ago.
A few months ago it seemed like it would not do this. Now in the past week I have come across 3 different ones that did something similar. Just 'stuck' in a local maxima and getting the AI to go around it is a pain. This is probably me and the way I am using it.
Is this better than I had a couple of years ago? I am not sure. Seems different at least.
> we will be partnering with HackerOne and Calif who are helping us take our efforts further with vulnerability triage, coordinated disclosure, and additional focused vulnerability discovery efforts
Calif found the vulnerability while working under an initiative lead by OpenAI, using publicly available AI tools developed by OpenAI.
Speak for yourself. I don't see every model being released under GPL after having read the entire source code as a step of creating their binary artifacts (model files).
The point of the open source I work on is to contribute to a commons, not to have it stolen so that it can be used to destroy those commons, used for the profit of techbros, and used to justify the murder of children.
I am one of those employees who can make architecture decisions, and make them well, and have for decades.
The level of appropriate LLM usage in my opinion? Ask Gemini some questions when you need to search the web then read the sources it gives you.
LLM written code still has the problem IBM identified. A computer cannot be heald responsible, and so it cannot be allowed to make decisions. That applies to executive management AND software engineering.
Of course that requires working in an industry, like aerospace, where engineers are (usually, Boeing not counting) heald accountable.
You are not paying attention then. Lots of programs have all sorts of basic things that can be changed with low risk to get pretty good performance benefit, for example. You can literally just ask an LLM to look through your code and see where you were e.g. unnecessarily allocating or had poor struct ordering and fix it without changing any interfaces or functional code and have it ensure that unit tests pass and that it runs benchmarks to see that the code is faster.
You can ask it to implement the pattern you want. Like we had a bunch of gnarly intertwined logic inside of looping constructs that I could say, hey, create iterators for this, extract out the filtering logic, extract out the transformation logic, etc. I'm making the decision, but it can do the mechanical work. And again, I can tell it to benchmark my refactor to ensure that it actually cleaned up allocations instead of introducing them. It becomes easier for me to actually be more thorough in my work.
You can also use them to quickly build out prototypes for different approaches so that you can make better informed decisions at an architectural level.
You can give them a description of a bug and it will read through your code and figure out where the problem lies, even across multiple repos with complex interactions. You can of course still confirm it, but they've been superhuman at this since at least last December.
LLMs are absolutely a game changer for software development in the hands of somebody who knows what they want. For low-level things, they're an extremely solid junior (they don't ever really make mistakes, they just write tasteless crap). For high-level things, they're an extremely solid discussion partner with wide knowledge and great reasoning skills.
The constitution generally, at both the federal level and state levels generally has a clause like "if its not enumerated here then the next division down has the right to regulate it" hence why the feds regulate interstate commerce, but not state internal commerce. This usually stops at the county level, not the city level, but large cities are effectively their own counties so that distinction doesnt matter much.
Its enforceable in that the city has a police department and zoning rights. So they can force businesses out for violating the law, and they have they have the monopoly of violence within the city to make sure you follow their directions. But whether thats funded or practicable depends on other factors.
There are only 2 divisions in the constitution, federal and state. Everything further down is not covered. States are allowed to rule over counties and cities absolutely, and can even dissolve them entirely.
Boeing and other defense contractors dropped it because C++ programmers were cheaper on paper (not realizing/caring that good C++ engineers were more expensive).
reply