skysight-inc/HackerNews huggingface dataset:
It is, in fact, never a surprise when a modern C++ program runs the first time without faults. That is an important difference from C, and a quality it shares with Rust.

What is missed by the authors of all articles of this kind is that, while all of the errors cited are possible, none are tempting.

For example, while it is easy enough to overindex an std::vector<T>, the language provides a "for" statement that exactly walks the vector with no possibility of overrun.

Using an empty std::optional<T> may seem like a danger, but nobody uses one unaware that it might be empty; it needs different syntax to look into than a regular value.

std::string_view and span, similarly, may seem foolishly risky, but they are always safe when passed down a call chain. One does not find them returned from functions in a responsibly designed codebase.

C++ is a box of sharp tools that a responsible engineer can use to make fine, reliable software. We have, today, many, many times more responsible engineers writing good C++ code than we have Rust coders in total.

Work making C++ code safe and reliable thus has a much bigger impact on the world than anything ever done with Rust. That will be true for a long time to come. That is not a reason to avoid Rust, but it is a reason to remain respectful in interaction with those engineers.
I wonder what the terms are - they're not public, are they?
Easily dealt with with a linter. C++ is not fundamentally a safe language. It's fundamentally a no-cost abstraction language. It's not a baffling design choice if you know C++.
I agree with someguy101010. I don't think it's anyone's business outside the university since this is between them and the kernel team.

I would imagine the kernel folks wouldn't be apt to make it public since it would draw even more attention to this than really needs to be brought, at least from the university's perspective. It would start to smell a bit of airing dirty laundry.

The damage has already been done. There's no need to make it worse.
Rinks are extremely safe. They are air conditioned, filtered. In Belgium, there have been zero recorded infections from the rinks across all of last year when they were still open - limited attendance, masks, etc.

For comparison, swimming pools are open. Their showers aren't, though. Something about it not being safe, so instead people don't soap up before getting into the pool. It's gross, idiotic and all in the name of COVID.

There's a lot of these absurdities going on, it's pretty easy to find them if you look. It happens, of course.. but it is demoralizing. I'd invite you to consider how you would feel if your local government closed everywhere in the country where you could run. Closing off not just your sport, but your psychological break from the world. Your mental pillar.

Back in winter when the lakes froze, our equivalent of the parks service decided people skating outdoors, on lakes, was a COVID risk and forbade it. Even some of our official experts called it an absurd move.

And no, exercising less has had a pretty bad effect on my body, regardless of what I eat. My core and leg muscles are not doing well after 7 months not getting their daily routines on the ice, and I simply don't burn passively as much as I used to, despite doing what I can at home.

To be honest, as someone who struggled with weight most of my entire life and only got it under control after two decades thanks to those rinks, I find it pretty off-putting the way you're implying how simple it is to control weight. Maybe for you it is, but one look at obesity rates unveils the truth for most people.
It's very possible, check out code for glfw, sdl, and sokol and grep for "cocoa", "mac", but you do need ObjC, which can be written in C files with -ObjC flag.
I don't know if it's actually wrong though, given that a procedure is just a block of code with one entry point (and let's say one return, for the sake of discussion). I'd have to jog my memory, but I'm thinking: if you can already optimize inside a function (but outside basic blocks), then I don't recall what would be so drastically different across functions. The fundamentally hard part does seem to be going from one basic block to multiple. I might be forgetting something though... do you recall?

Also, I don't think they're alone in this terminology either... see here: https://www.csd.uwo.ca/~mmorenom/CS447/Lectures/CodeOptimiza...
Where have they said actions have been taken?
The problem is that most of the big tech thinks they are smarter than 1000's of codec engineers who worked on libx264 and they try to reinvent the wheel. They realize too late that all the money they threw into building their own stuff (or variants) do far worse in general case than the baseline libx264. They just don't want to admit it.
The ideas expressed in this article should be applied to government. Everything in government should be a financial transaction. I should be able to see a list of what my federal income tax dollars pay for as a percentage of my tax contributions down to the 0.1% mark. Those assessments should be based on the real money government pays not the estimated funds that float around a bill or a budget.

My thinking is that if people actually saw what they are paying for they would advocate for different policies because it feels great to spend other peoples’ money from some magical endless pool of money on programs that at the surface make us feel good.
"separate" if you ignore that they have the same faculty advisor.
langis (signal backwards).
I can't speak to the others but judging by the amount of spam I get on Discord, they certainly aren't.
> and while the one that most recently submitted patches did nothing wrong the one behind the "hypocrite commits" did.

The commit that spurred this whole mess was for static analysis research, totally unrelated to the previous commits from quite some time ago related to bugdoors in the kernel.

Greg's reaction was to the static analysis commits, and he alleged (in an incredibly insulting and hostile way) that they were made with malice.
Rich Hickey A Programming Masterclass (1 of 2)
2019 Datomic https://www.youtube.com/watch?v=9TYfcyvSpEQ

2019 Episode 158 https://www.youtube.com/watch?v=TFnBYijSqvg

2019 Are We There Yet https://www.youtube.com/watch?v=ScEPu1cs4l0

2019 Death by Specificity https://www.youtube.com/watch?v=aSEQfqNYNAc

2019 Clojure core async https://www.youtube.com/watch?v=drmNlZVkUeE

2019 Design, Composition, and Performance https://www.youtube.com/watch?v=MCZ3YgeEUPg

2018 Are We There Yet? https://www.youtube.com/watch?v=E4RarTAZ2AY

2018 Maybe Not https://www.youtube.com/watch?v=YR5WdGrpoug

2017 Effective Programs https://www.youtube.com/watch?v=2V1FtfBDsLU

2016 Spec-ulation https://www.youtube.com/watch?v=oyLBGkS5ICk

2014 Transducer https://www.youtube.com/watch?v=6mTbuzafcII

2014 Inside Transducers https://www.youtube.com/watch?v=4KqUvG8HPYo

2014 Harmonikit https://www.youtube.com/watch?v=bhkdyCPYgLs

2013 This is Not a Roadmap https://www.youtube.com/watch?v=I5iNUtrYQSM

2013 The Language of the System https://www.youtube.com/watch?v=ROor6_NGIWU

2013 Datomic https://www.youtube.com/watch?v=4iaIwiemqfo
In a way, I agree. To me, C++ is an absolute train wreck of a language and choosing it for a new project borders on malpractice.

But if people want to use it and it doesn't affect me, there's a limit to how much energy I'm willing to spend trying to talk them out of it... especially if they are a potential competitor, in which case I might nod encouragingly when I hear they're using it.
So what? Who cares if they do? Static analysis fixes, whether they're good or bad, are harmless and not malicious. Greg attributed malice to them.

I'm sure many advisors have tons of students contributing to the Kernel or other projects, every single year.
Do you know anywhere that actually use it? I've heard Walmart Labs, but that's about the only place I know about.
Rich Hickey A Programming Masterclass (2 of 2)
2012 Hammock Driven Development https://www.youtube.com/watch?v=f84n5oFoZBc

2012 Simplicity Matters https://www.youtube.com/watch?v=rI8tNMsozo0

2012 The Value of Values https://www.youtube.com/watch?v=-6BsiVyC1kM

2012 Simple Made Easy https://www.youtube.com/watch?v=oytL881p-nQ

2012 Deconstructing the Database https://www.youtube.com/watch?v=Cym4TZwTCNU

2012 Interview with Rich Hickey https://www.youtube.com/watch?v=sf-lrFERkvs

2012 ClojureScript https://www.youtube.com/watch?v=tVooR-dF_Ag

2011 Simple Made Easy https://www.youtube.com/watch?v=kGlVcSMgtV4

Inside Clojure https://www.youtube.com/watch?v=wASCH_gPnDw

Clojure, Made Simple https://www.youtube.com/watch?v=VSdnJDO-xdg

Clojure Concurrency https://www.youtube.com/watch?v=dGVqrGmwOAw

Clojure for Java Programmers Part 1: https://www.youtube.com/watch?v=P76Vbsk_3J0

Clojure for Java Programmers Part 2 https://www.youtube.com/watch?v=hb3rurFxrZ8

Clojure for Lisp Programmers Part 1 https://www.youtube.com/watch?v=cPNkH-7PRTk

Clojure Data Structures Part 1 https://www.youtube.com/watch?v=ketJlzX-254

Clojure Data Structures Part 2 https://www.youtube.com/watch?v=sp2Zv7KFQQ0
So You’ve Raised a SaaS Mega Round: Now What?
Yep; fast+safe+well-tooled common IO format for tabular data, especially columnar, for going across runtimes/languages/processes/servers with zero copy. It supports a variety of common types, including nested (ex: lists, records, ...), modes like streaming, and schemas that can be inferred+checked, so it covers a lot of classic protobuf messaging use cases.

When messages look more like data, even better, as columnar representations are often better for compression & compute. So it's pretty common now for data frameworks, and increasingly, DB connectors. Ex: Our client https://github.com/graphistry/pygraphistry takes a bunch of formats, but we convert to Arrow before sending to our server, we zero-copy it between server-side GPU processes, and stream it to WebGL buffers in the client, all without touching it (beyond our own data cleaning).

The main reason I'd stick to protobuf is legacy, especially awkward data schemas / highly sparse data, and I'm guessing, Google probably has internal protobuf tooling that's faster+easier+better tooled than the OSS stuff.
Web logic is in Hack (offshoot of PHP), but all of the surrounding infrastructure has always been heavily skewed towards C++.
Note that most old pixel art games didn’t look pixelated when you played them, because they’re actually dithered. They were made to be run through a composite cable to a CRT and use the dot crawl/rainbow/scanline effects to generate a smoother picture.

Which doesn’t mean you should keep a CRT around, those things are way too heavy.
I use it. VS Code+clangd intellisense makes it easy to enumerate available classes, functions, and members, and because you don’t have to remember excessively verbose objects, writing self-documenting C++ is simple. Plus, you get automatic syntax checking as you go. That you can get these in a less-than-IDE nowadays is wonderful.
Wow, Casey doesn't hold back. Clearly, without hesitating says that 100% of code written in RAII* style sucks. Interesting considering Stroustrup considers RAII to be "the basis of some of the most effective modern C++ design techniques."

I'd like to hear Casey's comments on TDD.

*RAII style is lumped together with try/catch, smart pointers, tons of malloc/free new/delete
Kind of? But there seems to be a bunch of barriers in making it happen:

SkSL warm-up doesn’t help newer iPhones using Metal.

Flutter recently migrated from OpenGL to Metal for all newer iOS devices. (Please reference Metal on iOS FAQ on which iOS devices are considered new enough to use Metal.) However, Skia currently only implemented the SkSL warm-up for OpenGL. So the SkSL warm-up would only speed up older iOS devices by default. If you find shader compilation jank to be an issue for your app on newer iPhones, please let us know by filing a GitHub issue. In the longer term, we have a plan to use test-based shader warm-up to mitigate this. If there’s an urgent need for fixing shader compilation jank on newer iPhones, please leave feedback on Issue 61045, and we can help you turn on OpenGL for your app.

https://flutter.dev/docs/perf/rendering/shader

https://github.com/flutter/flutter/issues/61045
Realistically, large numbers of people pay little to no tax, and so the amount they "pay" for every service will be small, if not zero or negative.
McDonald's the corp isn't hurt by this, individual franchise owners bear the cost. In particular, mcdonald's the corp mandates the particular icecream machine that is used, rather than allowing the franchise owner to pick from several machines. The video argues that this is done because mcdonald's is interested in benefiting the company that makes and services the ice cream machines.
That faculty advisor has presumably done nothing wrong as part of this group either.
I agree with this post.

Greg has conflated Aditya Pakki with the hypocrite commits. Aditya wrote a static analysis tool that generated some bad commits and many acceptable commits.

Greg accused him of intentionally submitting bad patches. That accusation appears to be false. Greg should apologize to Aditya.
About a decade ago, there was considerable interest in being able to charge content to your cell phone account. Some of that happened, but it never became a big thing, especially once cell phones went flat-rate.
I would add that, at the very, very least, they should give you a personal link to download a snapshot of all of your data from their cloud at the time of termination: email, calendar, contacts, photos/videos, docs, et. al.

As a point of interest, in the EU and UK, they probably would be legally required to do something like that for things like mail and calendars, because the GDPR says, roughly speaking, that they have an obligation to keep the data reasonably safe and an obligation to let the data subject have it in some useful format. I doubt those obligations would extend to other creative works you'd purchased, though, since among other things that would drive a coach and horses through international copyright agreements and several reasonable business models built on the resulting legal framework.
Those kind of files aren't the rendered audio, they're more akin to MIDI files, but specific to the SNES synthesizers. So they have a vastly smaller file size, and contain more semantic information, than a wav/flac/etc.
>That's been true for so many other features in C++ too.

Plenty of C++ features are zero-cost, not necessarily zero-overhead. To me having an optional without bounds checking is like obtaining a shared_ptr without incrementing it's use_count. It's like arguing that I should increment use_count manually so that copies are "zero-overhead". Sure it's "faster" but the design is still broken and will lead to all sorts of issues.

>Pointers require something to point to. Optionals can embed the value.

So? Just because it embeds a value rather than a pointer doesn't make your program any more correct. If the API designer returned an empty optional and you access it anyways you are still dealing with garbage data.

>And I mean, you could use this logic for everything else. Iterators, arrays, etc. should all have bounds checking too, right? If you want that, there's C#...

Ok? Then lets remove all overhead from the language. Why does shared_ptr increment it's refcount behind my back? No more shared_ptr. This kind of argument without nuance gets you nowhere. Likewise, unlike bounds checks, nothing about std::optional is forced or baked into the language. If you don't want to do null checking, then just don't use std::optional - the fast option is still there and unlike Rust, the fast option is the default.

Optionals are a great tool to eliminate null pointers from a codebase. It's a big enough problem that I would expect an optional type, designed in 2018 to get it right. Allowing automatic dereferencing is an oversight.
If something dies without anyone noticing, it has no value whatsoever.

Good riddance.

As a new software developer in IBM, UML scared the hell out of me. It gave an aura of needless complexity to software problems that needed to be tackled by breaking them down into manageable chunks and apply time tested solution patterns.

And the whole Architect thing in IBM, oh my god. They were literally seen as demi-gods that everyone aspired to be. Really bad entry into software engineering for me.

(I have come out of IBM, so all is well)
I have unpopular opinions about that as well.
Previous thread about the Apology (prior to the response):

https://news.ycombinator.com/item?id=26929470
Exposed Orwell’s Blueprint – Chapter Two – iOS
It's a testament to how damaging Greg's comments are that this factual account of the situation is not what people are talking about. Greg's comments were outright slanderous and incorect - he wrongfully alleged that Aditya was knowingly contributing bugs to the kernel, when he was only reporting results from a static analysis research tool.

And then Linux mob mentality took over, and Aditya has been dragged through the mud over it.

Again, based on false accusations. Aditya did NOTHING that Greg alleged. Again, NOTHING.

But facts will be downvoted because the Linux mob loves grandstanding on mailing lists.
His reaction was that after the previous incident, from a year ago, he couldn't blindly trust something coming from the same source. That group has done no wrong, but they are barely a part of this overall discussion.
Then maybe crypto isn't actually a feasible technology. Just because people get a dopamine hit from the money they make off it doesn't mean it's good for society when your burning energy the size of a small country to do sub par amounts of transactions per minute.

I've seen crypto be used largely for flash money grabs and little else since the entire thing started and I'm largely convinced that until volatility, speed and energy consumption are fixed it will only remain in that realm until it's inevitably cracked down on by various governments.

Those are some pretty big issues to solve and personally I think ETH is poised with PoS to solve those issues, or so I've been led to believe, and offer utility in those every day transactions but I'm not holding my breath because of issues like that that you've pointed out and people who only view it to be used for that aforementioned money grabs.

When I've used crypto I've used ETH exclusively for my beliefs there, but I'm really not all that convinced this will ever be more than a novelty in current form.

I'm no expert in the field and I don't even generally follow crypto more than the passing news article, but this continues to be my general perception, especially when things like Doge are surging in value with really no discernable economic basis.

Let the crypto hoards now rain down upon me.
Ask HN: How did you techies spend lockdown? Make anything cool?
The only explanation I can think of is that this is old terminology that has stuck around in course material based off older textbooks that aren't bothering with any sort of interprocedural anything.

Function boundaries do make things fundamentally more difficult than basic block boundaries, for a large number of reasons. You can no longer have single definitions of values and updates to those values are not global updates for the entire program. This is why you need stuff like context/object sensitivity for interprocedural analysis but it doesn't matter for local analysis. Graph structures also become way more chaotic, preventing the nice efficient lattice movement you see in classical local fixed point computation.

Like, static analysis and compilers is my job and none of my colleagues would use this term this way.

But clearly there is some material using it that way. Weird. I've been wrong before and I'll be wrong again in the future. So I'm happy to be wrong here. Clearly there are some situations where "global analysis" is used to describe whole-function analysis.
What about Newark? I went through Newark Penn Station a few times and it seems decent. Is it a PITA to go between Newark Penn Station and the airport, or is the airport itself a bigger hassle than most?

Last time I went through LAX there were no good options for getting from there to downtown LA.
Didn't make it that far. Time is too precious to waste on someone that is purposely wasting it.
> So what?

For research groups, the faculty advisor is the responsible party; once that party has been shown to act maliciously, extra scrutiny is warranted, unless there is some evidence that durable reform has occurred. (The same might be said less strongly of the institutional source, as well.)

> I'm sure many advisors have tons of students contributing to the Kernel or other projects, every single year.

And virtually all of them have not been—either advisor or institution—responsible for malicious kernel patches.

Actions have consequences.
Simply leaving out the pricing for the media and equipment makes it convenient for the argument. Other factors as you mentioned also factor in to the outcome.
What qualified in 1979 as "edible plastic?" Gelatin, like pill outers?
I think the idea is more like "the entire program is covered by lifetime analysis / borrow checking, so that nothing gets missed." Something like that?
What do you call "wisdom" that's passed from person to person, so everyone knows it, but it isn't actually true?

A huge amount of Boost is nothing but headers. And it's very easy to use those header-only libraries and avoid the rest. Sure, many people have just pulled in the entirety of Boost... but it's really strange to blame Boost for those bad choices.

By the way, a lot of what today is standard C++ had its origin in Boost. smart pointers, thread, regex, random, ratio, tuple, etc etc. All came from Boost, and those of us using Boost were happily taking advantage of it, while folks who believe the "wisdom" you just shared were building it yourselves.
Is an Activist’s Pricey House News? Facebook Alone Decides
It's not that simple. Especially if you deal with videos that have open GOPs and have multiple B frames in the GOP. The encoders don't do so great job in those cases. Also breaking the videos up into short chunks is easier said than done -- you need to understand where it makes sense to split the video, make sure the Iframes are aligned and generally try to keep the consistent segment size -- which with very dynamic videos encoded with different types of source encoders could result in very inconsistent performance of the encoder itself across the chunks. For that reason, it's always best to have some sort of two/three pass encoding where the analysis step is integral and then based on it the actual split & encode is performed. Which of course does not work for low-latency live streaming scenarios.
The solution mentioned in chaifeng/ufw-docker is not beautiful too, because now you have to configure UFW each time after you deployed a new container since the IP address of each container is different. And you probably don't want to use an IP range for UFW because that will bring you right back to square one.

A better solution is to use an ingress controller such as Trafik and expose it to the Internet. Then when deploy later containers, don't use `-p` at all, instead, ask Trafik to route the traffic to the container.
Jeez 3/4 of that page were ads
Did University of Minnesota have any type of IRB? I sorta hope this can be the "come to Jesus moment" for academic CS to implement safeguards (such as IRBs) to prevent harm.
Someone Has to Run the Fabs
Excellent start!

You might want to refer to the mathematical foundations of

information that is in disagreement since empirical

information is always subject to disagreement.
> especially since usually nobody attempts to attack it.

Don’t tell the folks at UMN, they’ll look at it and think, “OMG! It would be so easy to cut with an axe. Such a massive security vulnerability. Bet I could write a paper about this. Where’s my axe?”