skysight-inc/HackerNews huggingface dataset:
That’s true but try also

1) Nothing says they can’t have had a similar religion (at least the early YHWH cultists) where there’s many gods but one overarching force. But also

2. YHWH is not a member of that pantheistic hierarchy. He is a foreign god theorized to have been imported by a merchant class. It is YHWH worship I find connections with not (necessarily) the ancient Levantine religion.

Anyway it’s not my approach, just a playful intuition.
The added bonus to writing good comments is you’re practicing technical writing directly associated with your code.

It’s similar to writing your own flash cards, but by rephrasing the code into a comment you’re visually and linguistically using a form of repetition to stick the code inside your head with a human readable explanation. This can make you a better technical communicator when discussing any code with others.

There is a lot more than “I will read this comment in 6 months and it will save my ass” going on when you practice writing good comments.

I really like this because in my opinion, half of my job is good communication, another quarter is planning/design, and the final quarter is actually writing code.
In fairness, using integer handles instead of pointers is pretty idiomatic in high-performance C++ too. I've never found it to be onerous or complicated.
Dereferencing NULL pointers: my code is structured such that every function parameter that can be NULL is marked so. And I check those possibly-NULL pointers.

This could also be done with a macro:

#define y_d(p) ((p) == NULL ? abort(), *p : *p)

Otherwise, the compiler (clang, usually) warns me when a NULL pointer is passed in and I have asserts to catch them.

Even before I had all of this infrastructure, deferencing NULL pointers was not a problem for me personally; it's just one of the mistakes I tend to not make. So that's why I don't have a macro for it.

For use-after-free, I use scopes. My stack allocator has a function that will mark the start of a scope, and I call it when entering a new scope. Then the pointers that are allocated during that scope will all be freed when I call the function to free every item in the scope, but those pointers will also go out of scope, which means the compiler won't let me access them.

It looks like this:

void
func(size_t s)
{
y_stackallocator* p = y_strucon_stackallocator();
// Random code.
// Open a new scope. Notice that the scope is a bare scope.
// But it could also be an if statement or a loop.
{
size_t* sp = y_stackallocator_malloc(p, sizeof(size_t) * s, NULL);
// Random code.
// This frees everything in the scope, including sp.
y_stackallocator_scopeExit(p);
}
// Scope has exited; sp is not accessible, no use-after-free.
}

This is less rigorous than Rust, but I use the principles in Joel's "Making Wrong Code Look Wrong" [1] here. If I have scopes that don't look like the above, they are wrong.

[1]: https://www.joelonsoftware.com/2005/05/11/making-wrong-code-...
From the article:

" Although critics question the legality of TRAPs, a legal analysis published last year found that courts generally uphold the agreements in challenges brought under anti-kickback provisions of the Fair Labor Standards Act, the law establishing a federal minimum wage. However, the author of the study, Loyola Marymount associate law professor Jonathan F. Harris, said another type of legal challenge might prove more successful: courts could refuse to enforce TRAP contract language under the so-called unconscionability doctrine, a legal principle that allows judges to void agreements containing unreasonable terms dictated by a party “with superior bargaining power.” In 2000, the study noted, a federal judge in Manhattan nullified one employment agreement in the financial services industry, ruling that the language of the contract “approaches indentured servitude.” "

Additionally, it does not cost tend of thousands of dollars to have a law firm draft demand letters for debt. Even if the debt is contestable, theoretically, it remains a huge problem and not something that can be ignored.
It’s a bit frustrating to see the first item related to parallelism and the GIL. Anybody doing parallel compute in Python has long since worked around these issues. IMHO Python needs better single threaded performance first, and then once all the juice has been squeezed from that lemon, we can sit down and get serious about improving multi threaded ergonomics.
My subjective opinion is that if you hire experts, not just programmers but experts at aviation programming, then possibly someone would have noticed a gap in the logic of the requirements and systems engineering. Who knows for sure? But I know plenty of contractors who write good code but oftentimes it's the architect level expert that knows what's beyond the code.

Especially when the code is directly responsible for a physical system.
What's the equivalent in Rust to Eigen, Ceres Solver, OpenCV, JNI and Qt UI bindings?

This is my standard stack for C++ and last time I checked Rust couldn't do any of them. This is also my standard stack for building new open source computer vision libraries, growing the available libraries and making my field more locked into C++, increasing the moat Rust would need to cross.

Next step, can I compile and deploy for Windows, macOS, Linux, Android and iOS? All of these are critical business requirements. This is whether I can adopt Rust in my employer's codebase.

Finally, can I easily find and hire engineers who can read and write Rust who aren't asking FAANG compensation levels? This is the blocker for Rust in startups.
Many thanks for sharing this information with us.
Hosting a Reactjs meetup this Wednsesday 9/21 if anyone is interested in frontend. We had a great meetup last month with about 80 people in person!

Details + rsvp: https://meetu.ps/e/LqXw7/gz2nM/i
Wait til you notice some 1% of the posts on the first few pages are keyword-targeted for you based on things you’ve discussed elsewhere.
> If you have structured data, that data should be contained in structures, not cons cells.

There is pattern matching on structures. If you switch from conses to structures, the relevance of pattern matching doesn't go away.

Types divide the data into categories, but the categories don't capture all the variation among the instances.

Pattern matching in functional languages is mostly done on algebraic types.
We need to take another try at involuntary institutionalization of the mentally ill.

It should be cheaper than prisons and more humane as well. The homeless crisis begs for this.

Just got to work out trivial details like how to not have that power be abused...
I think deadlines are really tech debit & credit, it's useless in a technological sense but a driving force business-wise.
The idea is that the cult that became Judaism has a shared history with Vedic, or pre-Vedic, religions. Not that ancient Israelites actually believed in that religion.
The distinction actually makes perfect sense during the hiring process.

If a recruiter approaches me with a C/C++ gig then I will immediately assume that either the hiring manager doesn't know what they want or the hiring manager didn't actually write the job specs, none of those scenarios sends a positive signal.
They should totally allow this. But... Since this debt is a form of specialized investment, turning the relationship into a business deal, it should be available only to employees that are accredited investors. Gotcha!
Well (Hy) there! would have made for for better HN s-expression tape conjuring language dual.

(visual image) : https://camo.githubusercontent.com/eea10b37eb037c82285364013...

[1] : https://github.com/hylang/hy
Those mom an pops own ETFs and index funds which definitely allocate for risk based on interest rates and inflation.
Very cool ! For units conversion I use GNU Units. But qalc seems to combine the benefits of both the Python REPL and GNU Units. I just tried the command-line version and noticed it doesn't support recalling the history (UP arrow) and editing calculations. This is unfortunately a deal-breaker :-( Don't have time to submit a patch.
If the primary concern is the lack of a common packaging format/app store, please consider publishing to https://flathub.org/. It should solve these for you across all distributions.

Testing should also be simpler as most of your dependencies will bundled and testing in one distribution should suffice.
Technically, that isn’t necessary. You ‘only’ will have to redeploy your apps every two weeks or so with a fresh temporary certificate.
And how much compute time/power does “decompressing” take compared to a jpg?
> But the space between "Need to stay away from C++" and "Should probably just have written it in Go" seems to be getting smaller and not larger.

We also have D which can use C/C++ libraries seamlessly.
There’s some value in giving constraints to junior developers. There’s some value in getting senior devs to look at the calendar and re evaluate their plans. Estimates can trigger both of these, but they trigger bad consequences as well.

Personally I’ve found that an engaged boss who I respect and occasionally points out I’ve sure been working on X for a while, is everything okay? To be at least as helpful as schedules. But if I could figure out how to get that consistently, I’d be on a book tour instead of keeping an eye on some people doing a deployment while I should be in bed.
they are the same now in DSM-5. they are both ADHD, with subtypes of Inattentive, Hyperactive, or Both.
I definitely do this as well when I have a complex feature or pattern I need to implement. It’s best to break down the problem into solvable chunks and writing the comments out first helps you break it apart and also make sure you haven’t missed anything.

This is the stuff that a software engineering professor will tell you to do, you ignore it for years, and then later on, after you’ve matured, you find yourself picking up again because it’s just one of those incredibly simple and responsible ways to break down complex problems.
Link to actual list of price tier updates: https://developer.apple.com/support/downloads/price-tier-upd...
I used to live outside of Silicon Valley, can confirm that most companies don't pay that much. However, what you didn't say is far more interesting: that it's okay that they don't. That part is the real travesty, that someone would look at a salary and say, "They don't deserve that" rather than, "I deserve that too." The fact is that software engineering isn't about writing code. That bit is quite trivial in any engineers day. What's hard, dare I say what you're paid to do, is to solve problems. Process problems, efficiency problems, resiliency problems, security problems - you're made to answer questions, or develop systems that answer questions to some of the hardest problems corporations have - and you'd ask for anything less?

Boeing most certainly can afford to pay the price especially when human lives are at stake.
Neither Aleksandr Sorokin's 24-hour world record or Aidas Ardzijauskas's daily run have anything to say about persistence hunting.

Sorokin's run is way too fast. Aidas Ardzijauskas's run is too long and too frequent. For persistence hunting think walking and jogging.

Did you misread "The hunters run down an antelope, such as a kudu, … a distance of up to 35 km (22 mi)" as being 35 miles?
From the video uploader: “yes, we will run DOOM on this”
:)
There's a town in center Italy called L'Aquila, I faint for a moment, until I read Mexico.
Wrong, Walking can be more beneficial than even swimming or running if done right.

Please see: https://www.artofmanliness.com/health-fitness/fitness/heavyh...

Basically use all your four limbs while working out, even running appears to be a dumb way of exercising since only two limbs are involved at any given time.
Yes but everything is versioned so it's not like this will break any existing applications unless the user/owner explicitly upgrades (but then they should be ready for breakages).

The absence of versioning hell with Rust is one of the many things I love about Rust.
China could blockade Taiwan to avoid direct conflict
see mbroderson 'Nope. ...' for episode II
Blanket statements like this just show that people don’t understand why people stuck with a language.

I worked in C/C++ for a long time, though it’s been a while now. I just went to look at whether Rust had any bindings for MPI. It does - rsmpi. But they’re not fully implemented, and only support a restricted subset of MPI implementations which are pretty much the latest versions. Some others might work, but it is not explicitly tested against them. Without that, there’s a whole class of distributed applications that you’d be ill advised to write in Rust using that library, because it’s such a fundamentally core library for distributed applications, which needs to be compiled differently and with specific versions to handle the specialist interconnects on HPC systems. If you only support the latest versions, your code is not very portable to other machines.
It’s always fascinating to read these anti-deadline articles that assume deadlines are arbitrary things that exist for no reason.

That might be moderately true for, say, someone developing a new app feature that gets shipped to users who aren’t expecting it. However, it’s not true at all when the software development output is a gating feature for real-world contractual obligations and other such business drivers. In that case, target dates must be carefully forecasted and estimates must be performed with great care and detain. This doesn’t guarantee that a target date will be hit, of course, but it’s not impossible to produce estimates that are reasonable accurate a large percentage of the time.

Estimation, planning, and progress tracking are difficult skills that must be learned, but they’re not impossible. I suspect many of the developers who believe that target dates are always arbitrary, pointless, and impossible to estimate have mostly worked in big cash-rich environments where it didn’t really matter when a feature shipped. If you go to the other end of the spectrum and talk to engineers who work in industries where target dates are critical you’ll discover a lot of people who are very good at breaking down projects and accurately estimating dates without relying on crunch time to get things done. It may sound impossible if you’ve never worked in an industry that requires such precision, but it makes sense after you’ve worked in such an environment for a while.
> the big problem is that for applications that do need to do non-trivial reference semantics, Rust doesn't really offer much.

For those applications you can almost always encapsulate the unsafe code in a data structure library with a safe interface, such that the library is a tiny fraction of the application code. And in many cases someone else already wrote that library. For graphs, for example, there is petgraph.

> for applications that can easily fit within standard containers and standard allocation paradigms, C++ actually works really well already

Not at all. For example it is still easy to corrupt memory using C++ references. Just the other day I discovered a nasty little bug involving absl::hash_map: someone had written "map[i] = map[j]" which is unsafe if the element at i does not already exist --- it can trigger a rehash, invalidating the reference obtained by map[j].
The rest of the game remains unimplemented not because it couldn't be done, but just because it's a lot of work. World generation, mob logic, all the different crafting recipes, world generation, etc wouldn't impact the performance of the redstone system, but it's not necessary for the use-case of running CPUs fast.
I seem to be the same as I get older.

My Dad (also an engineer/scientist) and I joke that our brain is just a massive foreign key relation store to primary keys records on the internet.
Not for me. Maybe I need to dig in, I'm on bullseye, maybe it's only in the older build repositories?

Anyway, I found this https://github.com/qwfy/doc-browser that I'm compiling right now to see how it works, looks keyboard focused, simpler and supports DevDocs, and bonus it supports Hoogle if you're a Haskeller.
My daughter is left handed and has no problem with writing fast (at least for her age), fountain pen with (very) fast drying ink+quality paper. Otherwise, there are good pens now that are enjoyable to write nowadays.
I don't remember that case at all. Possibly because I'm not American.

Could you elaborate what would be a valid reason? From what you wrote, it sounds like someone started shooting after some kids said some things. I can see that as an argument for gun legislation, but not for installing microphones in public spaces.
Given the approach, they'll probably come back with better reconstruction/decompression too.
I don't really use Python if I can help it, but I'm still really glad to see people working on this. Whether I like it or not Python will probably always be some part of my job and I really appreciate that there's finally some focus on it getting faster that isn't just "write that part in C".
I would have complied if he said D lang.

Tried Rust, did not like it that much, compared to D.
> A very US-centric view is it not? Many places can force you to decrypt something by law. In fact the US does on entry to the country and can refuse entry if you do not comply.

I must not be explaining well, because you're saying the same thing I am. There can be consequences for refusing to comply, ranging from being turned away at the border to being thrown in jail, all the way to, in some countries, torture and execution. That's how the government gets you to comply.

But--here's the critical point--your compliance is required to actually decrypt the email/drive/whatever. This is unlike, say, a cloud hosting provider where the government can just show up with a warrant or probable cause and get the data without your involvement. With strong encryption your data is protected by math, and the math insures that the government or whoever has to go through you to get it. No exceptions. They might throw you in prison for the rest of your life, or threaten to kill your family to get you to give up the encryption keys. But they do need to get you to comply to get access to the decrypted data.

Likewise with blockchain technology. A court or law enforcement agency can't just appropriate stolen bitcoin. They have to either (1) recover the keys, or (2) have the thief pay an equivalent amount in reparations. What I'm saying is that they can't just show up at the Bank of Bitcoin with a warrant and request a stop payment, recovering the funds that way as they're used to with the legacy financial system. The blockchain is irreversible even in the face of the law, for reasons rooted either in physics (proof-of-work) or math (staking).

> The courts will have the power to force blockchains to reverse transactions or other fraud this way - at a technical level still quite difficult but if it becomes law then solutions to make it easier will be created.

No, at a technical level it is impossible. You could no more do this than legislate that pi=3 or raise the speed of light.
Do you have a tool that enforces the use of all of these macros and stuff? How do you know that, for instance, you didn't forget something? Seems like one slip-up is all it would take.
Anyone sacrificed their email and got the full top-n languages ranking from https://circleci.com/resources/2022-state-of-software-delive... ?
"I'm late"

"I own a real dinosaur"
Senior developer will be able to offer a range of options. X in year. Y in a month. Z in a day. Etc.
Maybe Z is good enough. Maybe only X is.
> Very basic question: [not basic at all question which has been the subject of decades of research and produced several specialized programming models]

(Brackets my own of course.)

Sharing data in concurrent programs is not trivial, especially in environments where data is mutable. The most trivial answer to the question is “message passing”, as in the SmallTalk notion of OOP or the Erlang/OTP Actor Model. Some solutions look much more like working with a database (Software Transactional Memory). Some models that seem entirely designed for a different problem space are also compelling (various state models common in UI and games like reactivity and Entity Component systems).
This is my main gripe with Rust. Things that should be part of the standard library are relegated to third parties, thus requiring developers to audit yet another dependency (and it's dependencies, and sub-dependencies, and sub-sub-dependencies, ...). Realistically, this just means I can't use most third-party crates, greatly limiting what I can do with Rust.

It's been a long time since I've been able to write anything in Rust despite loving the language. My last hopes for Rust are now in gcc-rs splitting the Rust ecosystem into two; the current npm-style crates.io ecosystem and a more destro-centric properly vetted package ecosystem. If this doesn't happen, I'll just continue to use other languages or limit my dependencies to those with sane package management (usually this means libraries written in C) until something better pops up.
> I am curious. Could you give some more context?

Probably talking about this: https://github.com/pyca/cryptography/issues/5771
Stuff like this happens: https://www.sfgate.com/crime/article/BART-takeover-robbery-5...

Hard to imagine how to solve it without surveillance.
Goodness, I love this. It's a great description of the approach.
> Andrew G. Huff worked at EcoHealth Alliance for a period of time and was a first-hand witness to the design and engineering of SARS-CoV-2. Dr. Huff has provided considerable valuable information to Renz Law concerning the origin of SARS-CoV-2 and the misbehavior that took place during the planning and execution of research supported by or conducted by EcoHealth Alliance. Information from his first-hand account, which is supported by a deposition under penalty of perjury, is included in this document.

...

> After being promoted to Vice President of EcoHealth Alliance, Dr. Huff had access to
information about the organization’s finances. He learned that EcoHealth was heavily dependent
on government contracts to remain solvent and that cash flow was often tight. He also observed first-hand that EcoHealth engaged in minor fraud by overbilling time on contracts and double-dipping on some contracts between government agencies and provide donors.

> Dr. Huff was routinely involved in meetings and informal discussions during which gain-of-
function research was discussed.

> During direct participation in the USAID PREDICT program, Dr. Huff saw first-hand that EcoHealth failed to pay adequate attention to biosafety, biosecurity, and risk management. The organization did not perform proper oversight of foreign laboratories at which research funded by EcoHealth took place. Dr. Huff expressed his concerns regularly and they were routinely
dismissed by Daszak and other EcoHealth staff.

> Dr. Huff met Dr. Shi Zhengli and Dr. Ralph Baric and attended presentations at which they discussed their work on the design and engineering of SARS-CoV-2 and the use of humanized mice in their experiments.

> Dr. Huff was involved in the creation of a slide deck presented to In-Q-Tel which included the use of USAID PREDICT funding to collect coronavirus samples from bats all over the world, to analyze these viruses to identify their most dangerous features to humans, and then create chimeras to test on humanized mice.
Rust isn't actually that complicated and more importantly, most of it makes sense. I don't feel the same way about C++.
> In other words, it's possible to put C and C++ on the same footing as Rust when it comes to memory bugs;

No. This is only true if you don't care about occasional bugs. e.g. hobby projects. But if you're talking about mission-critical or security-critical software, there is a gap - or a canyon - between C vs C++ vs Rust. And no amount of extra "efforts" by the programmer's part can bridge those gaps completely.