skysight-inc/HackerNews huggingface dataset:
That depends on the organizational structure of the teams, what they’re trying to accomplish, and the budget for resources to name a few things.

Generally I don’t view a “feature store” as being a simple lake of raw data. To me a feature store is a place where features known to have signal in a ML model are stored. It has structure, “clean” data (to the extent possible) and some pre-computed elements (e.g. aggregates over some commonly used time windows) to facilitate efficiency in the end to end ML pipeline.

I’d also argue a feature store is not complete unless there are tools and infrastructure to make it relatively easy to provision and access new features: that is, it should cover the issues you raise.
Because it is highly moderated and biased?!
Pros:

* Single version / branching for everything

* Commits that go across components/apps are atomic.

Cons:

* When it gets big, those features matter less

* Churn from other dev's stuff gets in your merge/rebase work.

* 'git log' and other commands can be painfully slow

* Mistakes in the repo (e.g., committing a password) now affect many more people.

Use for highly-coupled source bases. Where releases together and atomic commits are very useful. Every other time, you're probably better off splitting early and taking a little time to build the coordination facilities needed for handling dependency versioning across your different repos.

Note: I used to really prefer monorepos, but I've had some time away now to take a better look at it. Now they feel like megaclasses where small things are easier (because everything is in one place) but large things are way harder (because there's no good split point).
Saying AWS uses it a lot is very misleading. Same for Microsoft. I won’t dispute that there are some teams using it but the majority of new projects aren’t in rust and there’s no trend for it.
I'm currently rewriting the "industry" application I started 4 years ago in Python into Rust. At the time I wasn't sure if Rust was mature enough to use it for a critical application, and I needed to get started quickly so Python seemed like the right choice.

Now that the application has grown to be quite huge I really struggle to maintain the python code, I miss static typing. Big code changes are a pain to validate and regressions always manage to slip in the cracks. Meanwhile I've used Rust for some smaller, less critical components and it Just Works. C-tier perfs and zero crashes in 4 years.

I'm definitely optimistic for the future of the language at this point. The community is thriving and the language keeps improving, while not breaking backward compatibility and forcing me to update my code to make use of the latest features.
Software Scaling – Does It Matter?
The compiler would already evaluate most of this stuff at compile time, you just weren't allowed to rely on it until now.

e.g. char::is_ascii_alphabetic() was made const in 1.47, but 1.46 would already run it at compile time: https://godbolt.org/z/hWf65f

The difference is in 1.47 you can use the result to assign something that must be known at compile time.
The Idea Lifecycle: Why Good Ideas Are Not Enough
Siege dev opens up about his experience on working at Ubisoft
Yes, I took a weekly dosage of vitamin D once during these days. It was a friday afternoon in february or march. I remember this, because during that time I had a few dentist visits scheduled, which I cancelled.
You are correct, now that I think about it. I loved that machine. Passed it down to my mother who destroyed it in a week by dumping coffee on it.

"No big whoop. I bet you do it all the time."
I remember being mildly startled when I realized I no longer use Google to google.

https://duckduckgo.com/spread
Ask HN: Who are the REAL “ride or die” early stage VCs?
The Midas list is primarily valuable to LPs. It tells us who bet on winners, but is that really helpful to most early stage founders?

Sancus was the god of trust, honesty and oaths. I would rather know which VCs exemplify these qualities than someone who died of starvation because of his vain wish for the “golden touch”.

Which VCs have shown you loyalty, ESPECIALLY when times are tough? Extra points for the VCs that spent time with you when it was time to wind-down your venture.
R0 is not a constant inherent to a virus strain. It's a contextual number, determined by population and behavior, population immunity and other factors.

Rt is simply notation of an estimate of R0 at a particular time.

Either way, you're correct that "herd immunity", as used here, means the point at which time the infection rate begins to decline, and this is conditional on population behaviors. If people mix more freely, the estimate changes.

However, the observation that people don't mix uniformly still applies, even if they mix a bit more than they do now. To put it in a CS context, it's like debating the magnitude of the constant, when the algorithm has a fundamentally different asymptotic behavior.
You might want to look at Google’s python fire which makes this sort of thing obsolete.

https://github.com/google/python-fire

Just comment your code and get pretty arguments.
The big advantage of a monorepo is that dependency on changes to a "library" or component that gets reused in multiple places can be made explicit. A user can commit a change that safely modifies a library or component in a non-backward-compatible fashion AND changes all the places that use it. This is far simpler than the alternative of releasing a non-compatible version of the library/component and maintaining both in parallel for a period while the users transition.

The big advantage of separate repositories is that the work done on them is very clearly marked as independent. It becomes easier to take one component out and utilize it elsewhere... but at the cost of having to deal with dependency management. Dependency management is simple and automatic in easy cases and really terrible in hard cases (like when two components you use mandate mutually exclusive versions of a third component).

So I think the driving factor in the decision is the tradeoff between the degree to which you are willing to invest in careful packaging of each component (and the corresponding dependency management), versus your willingness to force everyone and everything to utilize the monorepo.

(Notice I didn't mention performance issues. I really don't think they are important enough the control the decision.)
I wish they'd also de-emphasize the ugly political memes that are constantly forwarded by some addicted folks.

I used to unfollow them, but recently found that if I blocked their sources instead it was more effective because I could still hear from them when they post themselves.

I just don't see any use for this content, it is 99% garbage.
ZFS v0.8.5 Released
Personally, I think once you get to a certain place, you don't end up doing this super often. I do think that it's a good idea whenever you feel like you need to do it, and it can help you get enough experience with the language to be able to get over that hump.

There are also a lot of nice features in Rust other than the pure absolute runtime efficiency.
My reasons for SPAs has always been complex behaviors on the app and state persistence is a PITA if you don't end up with a nice MVVC on the front-end.

Not saying not possible to make complex pages without SPAs, but there are some things that are harder, and some that are easier.

Personally I love writing SPAs, I find that I end up making less complex code which ends up being easier to maintain. Not counting by the number of lines of code, but counting by how easy developers find it to change the logic without breaking everything in a complex codebase.

So idk, maybe I'm doing it wrong.
If you want people to use it at the kernel level (with libbpf and C programming), better documentation. XDP has a fantastic tutorial[0], but everything else can be quite difficult to get into (this is from personal experience). I've been toying with the idea of starting my own version of the XDP tutorial for other BPF functions, but I don't want to start without support from the larger BPF community. They've been somewhat supportive but seemingly not the most willing to help (which they're under no obligation to do so and I don't think they should be).

For BCC and bpftrace I personally think the documentation is actually quite good.

[0] https://github.com/xdp-project/xdp-tutorial
Sounds a bit like SOAP, COM, or XML-RPC
Very interesting! I've had this idea in my mind for ages but never see how it could catch up with enterprise-y type customers, but I suppose a pandemic can really be a motivating factor
When non experts talk about herd immunity they mean herd immunity given no to minimal precautions. This is a well defined concept.
The why ask him to denounce it?
Reduced overhead for ci/cd, code review, code syncing and branching.

No need to sync multiple repos and have complicated dependency versioning for in house libraries.

In house libraries are easier to refactor as dependent code can be updated in a single PR.

Code tends to be more reusable and you tend to make more reusable libraries as it is as easy as creating a new directory in the repo.

Services and tools can still have separation of control with all the monorepo advantages.

The only reason to not monorepo is if you are thinking of open sourcing the lib/tool you’re building but even then you can cut it out of the monorepo.
>>it says absolutely nothing.

Except to describe the entire history of the last, maybe 150-300 years, and the dilemma of the next 150-300 years.

And, anyway, I enjoy a good firework, but I never said I wanted our world to be one.
I don't have a lot of experience with monorepos but I've found them very useful for:

- Simple projects with a server and an SPA component - frontend and backend code for the same feature is on the same feature branch, can be tested and reviewed together.

- Projects with a couple of microservices that share some common libraries - these libs can be directly referenced by the microservices instead of being published on an internal package server. This of course has its drawbacks too but overall, the benefits have outweighed them.
It would also be interesting to hear about the tooling available/recommended for maintaining monorepos.(ideally FOSS tooling, but good proprietary ones as well)
Makes sense. For me, I see the preprocessor as a fundamental part of the language, since that is how it is implemented in C and C++. I was figuring that it would take just as much effort to implement/change a preprocessor as it would to change the core language.
Mostly there are zero suspects. These subpoenas are, as you point out, ways to find more suspects. There's just one issue: they also often only turn up ONE suspect. And here's the thing with people and police: everybody lies. The victim of the crime lies. Suspects lie (but the thing is: suspects lie whether or not they've committed a crime, this is not a difference between innocent and guilty). Witnesses lie (don't want to get caught, and yes the police encourages this, at wrong parking. Police will encourage them to lie, because they can't ignore a confession of wrongful parking and they understand they'll lose cooperation if they write them a ticket for their trouble). And of course the police officers themselves lie.

Whatever hope you have of finding the underlying truth in such a haystack less than a few years of work ... forget it. And then comes Google with "concrete evidence". Something that is actually true. Very likely not related to the crime, but true.

So you can probably understand that this would introduce quite a big bias against a "suspect", when their real connection to the crime is "someone was shot, and this guy googled 'gun' 2 days before". Furthermore, this gives them something to put to a judge or a jury, when before they had nothing, or nothing coherent.

Do you really think at this point a police officer, judged by the number of cases solved, bad guys put away, just walks away without at least applying very strong pressure on whoever was fingered ?
Using Minecraft as a Kubernetes admin tool
We have 3 cats and just got a puppy. The dog is already much more beloved and worth the higher effort than the cats have ever been. Cats are basically dry goldfish that you can play with and pet a bit. Dogs are part of the family.
Fortunately, if Russia tracks my every move, it will have no effect on anything at all.
https://www.medrxiv.org/content/10.1101/2020.07.23.20160762v... was a similar study a couple months ago that estimated 10-20%, rather than the 34.2-47.5% in this paper. The bigger question is how long immunity lasts, which is still not known.
Jacques Monod – Molecular Biologist Who Exposed the Soviet Union
Why the massive downvotes?
> $500k is much more than a sitewide external app pentest of comparable scope would cost Apple, by an integer multiple.

By a team of four experienced security researchers working for multiple months?
How do you test if a product is durable or not? I mean what's the time frame?
It's a memory safe language, and CFI has overhead.
Google posted a paper detailing their reasons for choosing monorepo: https://research.google/pubs/pub45424/

Caveat: your company probably isn't Google, so your challenges may be different.
except why would I want to risk long term effects for the rest of my life just because you want to make more money?

do you people on this forum lack any and all empathy or are you all proud sociopaths?
Gimme one reason to stay here... And I'll turn my back around
DDG doesn't record search information in the first place.
One thing you can do is wrap everything in Rc<>. This makes the held object reference counted and you can copy references around as you feel like. This gets you ownership much more like what you would get in a GC language (e.g. C#, Python, JS), but in an opt-in fashion.
https://course.fast.ai/ and the associated book are very helpfulf if you're coming from a software engineering perspective
“Hack Linux Sandbox” (Fake) Web OS for Hackers (Feat. Cowsay)
So how did the Spanish Flu disappear?
> Each herd immunity level is thus dependent on health measures

This seems like something you made up. Can you cite your source?

How exactly does your rule apply to non-humans? What "health measures" do packs of wild horses take when disease comes to the herd?
Mono repos can be useful if you have different services that are highly dependent on each other. This lets you package releases in a simple way by just tagging the repo. That tag/release gives you the exact version of all the components that you need.

But CI becomes substantially more complicated. You have to figure out with every commit what actually changed and based on that change what needs to be tested and built. You don’t want to run a build of all components if you only changed a small piece of one component.
For me the biggest pro and con are the same thing. With a monorepo your respective projects' codebases become tightly coupled.

Why that can be a bad thing? Good software engineering practices tend to be associated with loose coupling, modularity and small, well-defined interface boundaries. Putting each project into its own repo, encourages developers to think of it as a standalone product that will be consumed by third-party users at arms length. That's going to engender better design, more careful documentation, and less exposed surface area than the informal cross-chatter that happens when separate projects live in the same codebase.

Why that can be a good thing? The cost of that is that each project has to be treated as a standalone project with its own release schedule, lifecycle support, and backwards compatibility considerations. Let's say you want to deprecate an internal API in a monorepo? Just find all the instances where it's called and replace accordingly. With a multi-repo it's nowhere near as easy. You'll find yourself having to support old-style calling conventions well past the point you'd prefer to avoid breaking the build for downstream consumers.
> It’s gotten to the point now where I sometimes think about writing a comment to “send it out to gain karma” in the same way that I think about “sending off a unit to collect resources” in an RTS.

This was an extraordinarily poignant quote that I empathize with greatly. The only reason I’m sharing it as a comment is because I believe that I can now also gain some karma with it as well.

What does this mean? Are these the beginning signs of an addiction to fake internet points?
Please read the article. If you have time, skim through the 450 page report.

The problem isn’t the companies are big, the problem is they have openly abused their market share dominance to stifle competition.

——-

What was Congress looking for?

As we've explained before, antitrust law isn't just about monopolies. Being the largest player in a sector—even if you're so big you dwarf any potential competition—isn't inherently unlawful. Sometimes that can just be the way a market shakes out.

Antitrust law is instead concerned with what you did to become dominant and what you do with the outsized power that comes from being the biggest. If you have a 90 percent market share but it all came from natural growth and you deal fairly with other companies and with consumers, antitrust regulators are probably going to leave you alone. But if nascent startups can demonstrate you used your bulk to knock them out before they could become real competition, or if competitors can show you unfairly leveraged different parts of your business to squeeze them out? Those are problems.
> a) bullshit

Please elaborate on how you know how I voted? Lets explore that logic and how you think to determine your manner of arriving at that particular prejudice
Big fan of CRA. I like the idea of bringing this to the full stack. Really cool this includes AWS and CD configurations. I've spent weeks setting that up.

Will you be adding other backend or auth options?
This post[0] by Tim Dettmers should help. Reading through the article, it seems like he covers a lot of ground and lays out choices quite well. tl;dr is that only Nvidia is your best bet for local computing power, stay away from AMD & Intel for now.

[0] - https://timdettmers.com/2020/09/07/which-gpu-for-deep-learni...
Do you work at Amazon? That's not what it looks like from the outside. Lambda and Fargate are huge services, even if they're not all of AWS, and it only seems like they're ramping up more, even just from looking at the rate they're hiring Rust devs.

Yes, it is not super massive, but it is in the production path for important things, and appears to be on quite an upward trajectory.
Germany doesn't have warrants?
Actually, the knapsack problem allows taking an item more than once. The problem described in the blog is the 0-1 knapsack problem which can be solved in polynomial time.
In my experience, I did eventually start to appreciate the compiler forcing me to address things up-front.

But as an aside, if you're just trying to prototype quickly, some useful "shortcuts" can be:

- Using `Box<dyn std::error::Error>` for functions which need to handle a result

- Using `unwrap` or `expect` to easily access Option internal values

- Using `unimplemented!()` if I'm trying to mock an API design. This one is nice because it will let you build out the signature including specifying a return type without having to build out the function logic.

Obviously these are shortcuts and not production suitable, but can be good to just get some code on the page that compiles
This applies surprisingly well to Twitter and most of online communities I met. The logner and less elitist they are the more the conversation quality deteriorates, it is after all a sign of popularization or vulgarization, which ironically both words used to mean the same but nowadays the last one is definetely pejorative.
I wish I could use monorepos more often!

The only legitimate reason I have encountered so far for not using a monorepo is open-source dependencies that the company maintains patches to/contributes changes to. In this sort of situation, you'll want to have them in their own repository so that you can go from "foolib v5 plus our changes" to "foolib v6 plus our changes" without too much fuss.
Yes, you'd say that the Red areas are on aggregate older, poorer and less likely to work from home.

That said, at my regional college in the Deep South, case numbers have dropped noticeably since the beginning of term - instead of 30 cases every day we have now ten, and there have been remarkably few outbreaks at frathouses, all that despite no organized testing.
That doesn’t sound like a closed system anymore.
I take your point, but Ruby vs Go isn't a reasonable comparison. Rust is a lot stricter than Go, by necessity (no GC), but they're both statically typed languages.
Things that change together, go together.
Monorepos prevent people from having to dig in all imaginable places of your version system to find all pieces of your application.
At the same time, if you have 10 micro services which are accessed by 1 frontend, it may be a little bit messy to keep all that code in the same place.

Common sense (which is not that common) is what should be used to determine. Ask yourself some questions:

- Does these repositories change together ?
- If the code is not together, one repo should be linked to the over via what (git tag ? version number ?)
- All pieces of the application are contained within a context ? Or they can be split (example, 10 micro services and 1 frontend, but 5 of those micro services are also used by another frontend in another project).

The main goal is to make things easier, some PoC and experiments may make it more clear because it really depends on the situation.
Google’s Supreme Court faceoff with Oracle was a disaster for Google
I am not sure how this answer my question. I understand that a feature store contain the features that have signal.

My question is about the operational aspect of online vs offline stores.

I.e. what happen if the features needed for a prediction are not in the ONLINE store?
I am not aware of any studies that definitively show an advantage for static or dynamic typing; there have been ones that didn't provide anything conclusive, and you could argue that the experiment design wasn't representative.

https://danluu.com/empirical-pl/ is a good place to get started on this topic.
I'm not sure what exactly you think I'm saying. My point was that this is a feature I would pay someone to provide me. Like adding: "Ad-Removal-Package - 5USD$" as an optional add-on.

I'm not saying I'll be giving them unfettered access to my browsing habits so that they can give me some perceived monetary benefit in return. But even if that were the case, so long as they didn't do anything fraudulent or violate my privacy by giving my personal data out, then I'm 100% fine with it. This is no different than Google having algorithmic access to all my personal emails. Once we figure out the two scenarios are the same, we'll quickly realize this whole "protect me from my ISP", "privacy" movement is just a front for taking away people's right to control their own hardware.
That's a misleading portrayal.

https://www.politifact.com/factchecks/2018/mar/22/meghan-mcc...

> The Obama campaign created a Facebook app for supporters to donate, learn of voting requirements, and find nearby houses to canvass. The app asked users’ permission to scan their photos, friends lists, and news feeds. Most users complied.

> The people signing up knew the data they were handing over would be used to support a political campaign. Their friends, however, did not.

> The people who downloaded the app used by Cambridge Analytica did not know their data would be used to aid any political campaigns. The app was billed as a personality quiz that would be used by Cambridge University researchers.

The Obama campaign's approach (consent on behalf of your friends) is now no longer possible nor permitted by Facebook's API and developer terms; Cambridge Analytica's approach was a violation at the time.