skysight-inc/HackerNews huggingface dataset:
> I'm not familiar with the GNOME story, but removing features takes courage

Courage is not intrinsically admirable. Whether it's admirable or abhorrent depends on the context of what you're doing. Ditto for sincerity.
You can use my keyword highlighter, at least for the invented words (needs modifications for multiple-worded names though):

https://openuserjs.org/scripts/danuker/Keyword_Highlighter/
>I think had Nintendo somehow ended up in a Philips-like deal with Casio, a port of Super Mario Bros. Deluxe to the Loopy may have been a success. Someone get on that.

1995 was just after Nintendo got burned twice by the Sony and Philips CD-drive deals. The likelihood of them doing another partnership like that with Casio would have been in "when hell freezes over" territory.
This is the right take on this. All tech people here that rave on that microservices really make their life easier even though they are working in a small team for an entire product are looking through rose colored glasses while chucking down the koolaid and also not the intended audience. The tech complexity is hardly ever worth it unless you are a large Corp.
Something being illegal doesn't necessarily mean that it is wrong.
If instead of a C2 Server the above approach was used for SciHub or other servers regularly censored by one government or another, I guess many people here would approve.
> Furthermore, it definitely just feels like a recategorization/relabelling on Brave's part to get some brownie points. Not that it's not interesting, but I feel it's just a new name but old concept.

More generously, I'd say they were giving the matter a more accessible name to raise consciousness about it and because they intend to do significant future work addressing it. There is a marketing angle to this: they might then claim to be the most private browser on this basis. However, given they are cooperating with other browser dev teams on this, if the danger of bypassing anti-fingerprinting measures is as serious as they say, this seems quite legitimate.
Reddit: Social media platform files to go public
It's just saying "Loading..." Both in Firefox and chrome
Hiring the Expert Furniture Movers in Calgary for Safe Relocation
Professional house movers in Calgary have undergone thorough training in order to conduct the safest moving methods. As a result, they can ensure the protection of their client's valuables. Furthermore, they are more capable of managing large and bulky goods such as heavy boxes and furnishings.
I’m using ESPHome extension for home assistant which has been fantastic because you can flash code on over the air and the initial flash can be done from a browser

(Which still blows my mind)
I never heard that Apple was decrypting the original content at all. That implies that there is a team at Apple looking at child pornography all day. Not sure how that's even legal. It was my understanding that CSAM systems were simply hash based and 'hits' were reported to authorities. Do you have a source for them decrypting information?
As far as I know China blocks a lot of things that seem indispensable to non-chinese audiences.
Oh sweet summer child
Org complexity is a valid point. Sure you can solve it using microservices. But in this particular case (solving org complexity) such "microservice" is akin to a library with some RPC. You might as well have each team developing their "microservice" as a shared / statically linkable lib. Same thing in this context.
Yeah I would say those are key value document based DB. Just silicon valley hipster coming up with cool names to call something different so it is a bit easier for developer to use. Anything does permeant storage are DB.
Getting a particular piece if code running from the first time is so unexpected that I'm like "Huh... that's pretty cool" everytime it happens.

no need to spend 3 more minutes looking at the code when a 2 seconds build will tell me there's a Segmentation fault right there, or when Valgrind will tell me I missed a free ().
The only thing you need to synchronise is API, no?
Which is where version numbers comes in.

To me, if youre working with a lot of modules/micro services, lots of modules should be able to sit on old versions and develop independently (which is the crucial part for 100 developer scenario)
I originally had my search engine running on a kubernetes-style setup off mk8s.

The code is a microservice-esque architecture. Some of the services are a bit chonky, but overall it's roughly along those lines, besides the search engine I've got a lot of random small services doing a lot of things for personal use, scraping weather forecasts and aggregating podcasts and running a reddit frontend I built.

I'd gone for kubernetes mostly because I wanted to dick around with the technology. I'm exposed to it at work and couldn't get along with it, so I figured we may get on better terms if I got to set it up myself. Turns out, no, I still don't get along with it.

Long story short, it's such a resource hog I ended up getting rid of it. Now I run everything on bare metal debian, no containers no nothing. Systemd for service management, logrotate+grep instead of kibana, I do run prometheus but I've gotten rid of grafana which was just eating resources and not doing anything useful. Git hooks instead of jenkins.

I think I got something like 30 Gb of additional free RAM doing this. Not that any of these things use a lot of resources, but all of them combined do. Everything works a lot more reliably. No more mysterious container-restarts, nothing ever stuck in weird docker sync limbo, no waiting 2 minutes for an idle kubernetes to decide to create a container. It's great. It's 100 times easier to figure out what goes wrong, when things go wrong.

I do think monoliths are underrated in a lot of cases, but sometimes it's nice to be able to restart parts of your application. A search engine is a great example of this. If I restart the index, it takes some 5 minutes to boot up because it needs to chew through hundreds of gigabytes of data to do so. But the way it's built, I can for example just restart the query parser, that takes just a few seconds. If my entire application was like the query parser, it would probably make much more sense as a monolith.
Well, not git, but modularity was invented for that.

You can have a modular monolith that works just as well with 100 people as something service-oriented would. The difference lies in the level of discipline needed. It's much easier to "just go in and make that field public because it makes my implementation easier" when you have a modular monolith. With microservices, you are more explicitly changing an external API by doing that.

Yes, it's the same thing. But somehow, psychologically, people feel worse about changing a networked API than making an identifier public instead of private.

Edit: I forgot, there's one more thing: with service orientation, you can deploy in finer grains. You shouldn't have heavily stateful services, but if you do (and you always do!), it can be cumbersome to redeploy them. At that point, it's nice to be able to deploy only the parts that changed, and avoid touching the stateful stuff.
I am not from Japan, but do work in two languages other than English (both official here). This is pretty typical actually. English names for identifiers (sometimes badly translated or simply transliterated), local languages for comments.
A lot of noise from changing single-quoted strings to double-quoted strings
Maybe I'm too old, but I don't even want to have to worry about all that. I think in terms of functions and I don't care if they are being called remotely or local.

That was the promise back in the day of J2EE, and it seems to me Microservices are just a rehash of that same promise.

Which never really worked out with J2EE - it was mostly invented to sell big servers and expensive consultants, which is how Sun made money?

These days I sometimes don't even bother to make extra interface classes for everything. If I need it, I can still insert that, but no need to do it up front.

And "DevOps" is just a ploy to make developers do more work, that was formerly done by admins.

Writing every Microservice in a new language also seems like a huge headache. The only bonus is that you can attract developers by being able to promise them that they can work with some shiny new technology. Maybe that is actually the main reason for doing that?

Otherwise, again, perhaps it is my age, but I prefer to minimize the dependencies. Do I really want to have to learn a whole new programming language just so that I can fix a bug in some Microservice. I personally don't want to.
Since there's very little mechanical work on a miner, it also turns one watt of electricity into one watt of heat. What it'll also do is generate a small amount of bitcoin to help you pay for the electricity.

It's sunk cost if you already have a miner and need a room heater.
Lichess uses Glicko-2 rating method, see https://lichess.org/faq#ratings
I wish the site explained _why_ this particular journal was predatory. Right now it seems to easy to convince the site to add $rival_journal to the junk journal list.
Office workers in Spain make $400k a year, with insurance and perks?
I feel like microservices are a solution for magpie developers. It's hard to keep a hundred engineers excited about working in an aging Java stack when there's all these shiny new tools out there. But maybe that's just my perspective, coming from a consultancy firm whose devs wanted to stay on the cutting edge.
>monorepo/monolith/microservices/etc" is -just- the way you organize your code.

It’s also about how you deploy your code. If you have 1000 micro services do you have 1000 deployment pipelines? If so how do you manage those pipelines? If not, you sacrifice independent deployment of each micro service.
Was working in a similar product and it was by far the worst dev experience I've ever had. It was actually worse than what the post describes. It was like having to go through a lot of stages to get to the area I'm working and half of them not working at all - so instead I was doing bug reports on other people's areas which was only slightly familiar with. (Yeah, our CI QA gateway was a joke. Our CI in general was a joke).

It was hell. That much so that I jumped to the first half-decent role that came my way.

Something is wrong with the way we build systems that integrate too many other systems. Perhaps if we designed them with a TDD approach all the way up things would be better...or worse. Dunno. Sometimes what we're trying to do is just way into the entropy zone.
Just disable all the subreddits but the few that you follow.

And also disable the trending option in your preferences
Its the (show trending subreddits on the home feed (a list of popular and notable subreddits to check out)) in your preferences.

And then your home page is normal, sure that should be the default, but it's not hard to do
If another community is mis-filing tags, your community can apply moderation against their community such that your community does not use their tags.

The other way to do this is to have just as good support for +tags in queries as -tags in queries. When adding a tag for no reason is making it less visible to the people who are filtering out that tag, they stop doing it.
Efficient rendering of soft particles on mobile GPUs
I would say that yes, in the long term. GNU/Linux on a phone does not have planned obsolescence and allows running desktop apps, connecting it to a screen and keyboard for desktop mode. I'm daily driving such phone (Pinephone). It's rough at the moment but getting good enough quickly.
They don't need to make money selling chips if they can license their IP to people who run the foundries. IBM's prodigious patent portfolio is a huge revenue source for the company.
No wonder, you have a bad time, if you associate microservices with k8s.
It's just a sticker, but a sticker that has a license. In the world where we live I would expect that something like this has to be aproved by a legal team.
"The following is an entertaining short story:
Once upon a time, there was"

Everything else that follows is GPT-3.
I seem to remember this in waterworld :). Yep sailboat.
1. That wouldn't work if code under test uses multiple transactions.

2. Rolling back a transaction is not exactly free.

3. Does not allow running multiple test simultaneously.
Unless you have a strong technical or organizational reason to use microservices, using microservices is just more work to achieve the same results.

Organizational reason would be multiple people/teams who don't want or can't talk much to each other, so they develop pieces of a larger system as relatively independent projects, with clear API and responsibility boundaries. Frontend/backend style web development is an example of such approach, even though we don't typically call these parts "microservices".

A technical reason I can see is some component of a system actually having to be written in a different stack, or to be run in a separate location for business reasons (separate physical computer, separate VMs or containers don't count). Like a firmware running on an IoT system. Or most of the system uses python, but there's a really good library in java for solving some very specific problem, so let's use it.

If neither of these reasons stands, you don't have a microservice architecture, you have a distributed monolith. You just replaced some function calls with RPC. RPC call which takes a much a longer time than a local one, and can randomly fail. Most of your microservices are written in a single stack, so you refactor common parts into a library, but then different services are stuck to use different versions of this library. You end up with a much slower and a much more fragile system which is harder to work on for no good reason.
I really like they use Hey to show how a real application can be done using rails. DHH shows the internals of Hey in some tutorial and I found it very interesting.
What has worked well for us, something that IMO combines the best out of both worlds:

* break down the problem into sensible components. for a reporting system I'm working on atm. we're using one component per type of source data (postgres, XLSX files, XML), one component for transformations (based on pandas) and one component for the document exporter.

* let those components talk through http requests with each other, including an OpenAPI specification that we use to generate a simple swagger GUI for each endpoint as well as to validate and test result schemas.

* deploy as AWS lambda - let amazon worry about scaling this instead of having our own Kubernetes etc.

* BUT we have a very thin shim in front that locally emulates API gateway and runs all the lambda code in a single process.

- (big) advantage: we can easily debug & test business code changes locally.
only once that is correct we start worrying about deployment, which is all done as IaC and doesn't give us trouble that often.
- (minor) disadvantage: the various dependencies of lambdas can conflict with each other locally, so gotta be careful with library versions etc.

doing so the scaling works quite well, there is no up-front infrastructure cost
and code tends to stay nice and clean because devs CANNOT just import something from another component - common functionality needs to first be refactored into
a commons module that we add in each lambda, which puts a nice point for sanity
checking what goes in there.
Maybe it is just me, but I always understood that properly designed microservices have their own specific datastore, which is not shared with other microservices even if these all collaborate to the same process.

If this is actually (still) true, that means that "the way you organize your code" is a bit simplistic. Your example of an "http api that converts pdfs to ..." is surely a valid example of a microservice, but most business products have to handle much more "state" than those, and this will create further complications which go far beyond "how to organize your code" (and make monoliths more appealing).
In the times that I used forums with phpBB and SMF I really liked that I could select the font that I wanted to use, using Comic Sans is a nice way to let people understand that you are using the satire.
Governments and companies like Google/Twitter definitely have some shady tracking practices, sometimes even tracking between different apps and websites, but it's still nowhere near as invasive as taking a screenshot of every single thing that happens on your child's phone.
Yes, it's essentially a factor of cost, not electrical consumption per se. So at best I don't see it helping to reduce the carbon foot print. In fact, there is a chance the problem would get worse.

Consider the Braess Paradox as an analogy. https://en.wikipedia.org/wiki/Braess%27s_paradox It's possible that increased efficiency (more capacity) would incentivize a greater number people to mine until usage was higher than before - similar to how expanding roadways creates more traffic. Then again, there might not be the time for the problem to get worse before people realized that money is the bottom line, not conservation. Why bother with greener chips.. when it's faster chips that matter. That's one of the big problems with proof-of-work consensus. The game theoretics work against our survival interests.
This is a Rule 34 corollary.

https://en.m.wikipedia.org/wiki/Rule_34
old.reddit is destined to be nuked after the company goes public.
One of my favorites: https://webonastick.com/fonts/routed-gothic/
Damn kids, get off my issue tracker!

https://github.com/webpy/webpy/issues/420
I wholeheartedly agree on most parts, with DevOps being the exception.

Devs only focusing on developing/writing source code is certainly not the way to produce sustainable, high quality software- at least in my opinion...
Unless you think hope is always logical or rational, then there are some situations in which suicide can be logical or rational. Or maybe simply humane, if you want. While reducing impulse suicides (and all suicides) is a noble goal, saying suicide isn't logical or rational to me is downplaying and disconnecting from the suffering of those that need the support (and not the judgement) the most.
"Could have gone wrong" is a mild phrase which doesn't reflect the reasons why there is trend against bullying.

An amputee might find strength and toughness in learning to adapt to being without an arm. That doesn't mean we go around encouraging people to cut off their arms. I suspect most amputees would rather not have to have that experience in the first place.

Quoting "Bullying: A Module for Teachers" at https://www.apa.org/education-career/k12/bullying under "Myths about bullying"

> Many beliefs about school bullying are not supported by current research. These are among the most common myths that even some teachers have been known to endorse: ...

> Being a victim builds character.

> Another misconception is that bullying is a normal part of the childhood and adolescence experience, and that surviving peer harassment builds character. In contrast to this view, research findings clearly show that being bullied increases the vulnerabilities of bullied children. For example, we know that children who are passive and socially withdrawn are at a heightened risk of getting bullied and these children become even more withdrawn after incidents of harassment (Schwartz, Dodge, & Coie, 1993).

How many other people suffered, in being part of the same bullying environment from which you drew your character?
I keep trying to do K8S at home but each time hit a wall of complexity and conclude this is ridiculous.

I’m sure has its place for bigger applications though

I do like a modular approach though (think docker rather than k8s) which I suppose is partial micro services
Monolith and Micro-services at different times during the progression of a business can have their places. I have experienced the pains of having to work with both within the same company over 9+ years and here is what I think are forces that can pull you in either direction.

A monolith makes developing initially a lot easier. Over 15 years though, you are bound to have developers of various calibre leave their mark on it. Many don't even understand good modelling and inevitably drive an otherwise healthy monolith with well defined boundaries into a soup of couplings between domain concepts that should not know about each other. In theory though it is totally possible to have micro systems within the same monolith code if you model things that way.

Eventually, your team will flip the table and start thinking how to avoid the problems they are having with the monolith and decide to do down the micro-services way. In most situations developers are likely to face a lack of commitment from the business to spend time/money on a technical problem they do not understand but have to support the development of for a lengthy period of time. Most developers will compromise by building pseudo micro-services without their own databases which send requests to the monolith where the core business logic had to stay.

The benefit of micro-services IMO is driven from being able to separate business domains in a way that keeps each responsibility simple to understand for a new comer and compact enough to not hide a great deal of complexity. It's worth saying this is a very hard thing to achieve and the average developer shop won't have the experience to be able to pull it off.

This is all to say, regardless of Monolith or Micro-services architecture, the key is experience and discipline and without a good amount of both in your team the outcome is unlikely to be a success over a long enough period of time. This is the curse of a business that lives long enough.
Kinda: http://www.aaronsw.com/weblog/rewritingreddit
Clarify the microservice architecture concept with "how you are going to deploy your system", as per your example, is exactly what I'm trying to explain to my teams since the microservice architecture inception. There are too many concepts conflating into the "microservice" term: code architecture(separation of concerns), source code organization, deployment, etc. This is very confusing, which is the reason why it's now common to say that microservices are "hard".
Ask HN: How to better understand studies and papers?
Hi,

I have a bachelors degree in a non-science related field so I have never conducted a research study myself. I find it very difficult to understand if the study I am reading is well thought out, with good practices or just comes from shady interests or publications.

How can I be better informed to distinguish between good and valid studies from the others?

How do I know if a study has been peer reviewed and what were the conclusions of those reviews?

How do I know if the methodology chosen for trials was right or flawed?

Is there any "Research Studies for Dummies" resource out there I can read to improve my knowledge on this?

Thank you
I don't even think the deployment pipelines are the problem. If you have 1000 microservices you have 2^1000 possible states of your application based on any of those services being up or down (reality is much more complex). It is genuinely hard to keep that number of services up and running so you then need to be extraordinarily diligent about how you handle failures.
Except that you do not need microservices to solve organisational problems. You need, as has always been done, to have well-defined modules with well-defined interfaces.
I always do this, but how do when to re-architect or at what level of granularity to look for optimizations? Do we burn time looking at async processing, do we just scale the cluster, etc
I remember reading sam newman and if I am not wrong, he says something along the lines of the team size, problem at hand and few other facts determine which one to choose. Nothing is a silver bullet. Trite, but it's having knowledge of multiple architectures and using the wisdom to choose when to use one.
Long enough mumble sessions will desync and the developers don't want to do anything about it. Mobile clients all suck. Mumble is great, but it has flaws too :)