skysight-inc/HackerNews huggingface dataset:
I really wish people would stop claiming that the solution to cars is walking or public transport. I don't have a car either but claiming that people should "stop driving" is not a serious approach.

Cars are extremely useful and are not going anywhere. They have problems like carbon emissions and being extremely dangerous but those will have to be solved while preserving the fundamental utility of a cars: They are individual vehicles that can go nearly anywhere and carry considerable cargo.
Compositors are starting to implement Wayland EGLStreams support, but it’s very shaky at the moment. As always, X works fine in some setups but is hopelessly broken in others (e.g. multiple NVidia GPUs connected to multiple monitors).
Could not agree more.

As someone who commutes primarily via bicycle, I've always been mystified by colleagues and friends who choose to drive to work in the densely populated northeastern city while cycling through center city is faster, more fun, better for your health, etc. There are obvious times when driving a car will make more sense, e.g. transporting delicate flowers, but for the average commuter it breaks down to the fact that the car is just somewhat sacred in our society. It is an important aspect of the American identity and our vision of success in this country, and so here we are, innovating around cars with technologies like self-driving rather than looking forwards to new potential paradigms of transportation.

This is just in regards to the average commuter, I'm sure that self-driving does have its place in like, moving 40' containers in low-density areas.
Yeah as others mentioned this is between C and C++, arguably taking best of each language. But indeed this library is based around the idea of having performant UI (as they mostly redraw whole screen on each frame, it has to be quite quick, though there are ways not to do this, this is the most basic case) and generic containers do not really cut it, also usage of exceptions is sort of impossible with the way you have to structure ImGui code. So it's more of a codebase that illustrates how to write performant code, not so much modern C++ guideline.
I was coding C++ (for graphics) in the early 2000s, and I (and I think most others I knew) would have considered it bad back then. But regardless, the topic isn't "C++ code that was considered good when it was written".
I think we have different definitions of 'deep.' If you cut too deep, the entire loaf will split. My wife just posted this to facebook today: https://ibb.co/TPXyS4S
It's security promises are snake oil until you have per-module security. Otherwise every demo app will run at the same level as node in practice. Except you gave a worse ecosystem and less to rely on long-term.
The problem with self-driving cars is the 1% failure of software.

Cars travel at a high rate of speed and a 1% error can easily be fatal. Either by hitting a pedestrian or someone on a bike, or by the car failing to acknowledge something and crashing itself head on into something.

Because cars travel in a highly dynamic environment this 1% error and the fatality risk associated with it is very high, so you need to have something that is 99.99999% safe which is extremely challenging because of the dynamic environment.

Meanwhile, if you look at automated train and rail systems. Because the environment is 99% controlled and less complex a 1% error is actually much smaller, because the environment is so controlled.

The high rate of speed, coupled with fatality risk, coupled with dynamic environments, is why this is such a challenging problem.
It started a long time ago, back in the days of mainframes and thin clients. Mainframe boxes would run the sever side part of "X Server" while clients (ambiguous term in this context, I'll admit) would send commands (e.g. keyboard strokes) and receive graphics back.

XFree86 is a free software implementation of the X Window System.

The whole server/client thing is a bit outdated now, since almost nobody uses actual thin clients anymore. X forwarding is useful, but it's not a mainstream way to do your computing.
That's a distinction without a difference.
I remember growing up adults just mentioned global cooling. No mention of global warming. Which gives me the impression cooling seemed the bigger concern back then. If so, that would explain this reaction by companies that either didn't think it the most likely scenario, or maybe thought it could be beneficial to fight the cooling effect.
Can you say more about how it's a problem if people can view things without logging in? Naively I would have seen that as a plus.
Thanks, I realized myself that what I wrote is flawed.

Even ignoring the literature you linked and just using common sense having a deficit puts a burden on your body and any additional burden when fighting some illness makes the fight harder. (Well, ok, there are some exceptions, humans are complex.).
See some more details around the motivations and history here: https://gouthamve.dev/tempo-a-game-of-trade-offs/

It will be easier and cheaper to manage compared to Jaeger but doesn't yet have any ability to search inbuilt (which is one of the reasons Jaeger is expensive).
Hell, I'd be happy if there was just fewer bugs.

Case in point: Gnome + Wayland + guake. If you configure guake to use anything less than 100% of the width of the screen, then it suddenly appears in the wrong position.

But wait, maybe that's a guake bug, right?

Wrong. I tried a couple of other options for similar functionality and they demonstrated the same issue. So odds are it's actually a bug in the compositor.

And that's ignoring that basic things like global keybinding don't work (edit: ya ya, the Wayland proponents will tell you that's by design, but it's a) user hateful b) totally different than literally any other desktop OS out there today, and c) breaks apps, right now, in ways that will require major code changes to fix) so I have to put a hack in place to allow F12 to open guake up in the first place.

Meanwhile, we only just got the "official" solution for screensharing (what Zoom does is an incredible hack: they just take lots of screenshots! No, I'm not kidding, that's actually how it works, which is why the framerate is so bad) and it involves yet more new stuff (pipewire, et al) that I'm sure will be a source of its own raft of bugs.

I'd say "maybe in a year or two", but we've been saying that for a long time, now...
That’s our motivation and experience over the last 6 months running it internally at Grafana Labs. Much cheaper and easier to operate.

Not to bash Jaeger though, its more powerful than tempo in that it allows you to search for traces. Tempo is about integrating with Grafana, Loki and Prometheus for finding traces.
And who's problem is that?
> The fundamental prerequisite for functional mass transit is a high population density.

This just doesn't seem to be true. It probably needs some density (think "town", not "farmland") but the fundamental prerequisite is a commitment to planning and building public transit infrastructure, rather than automobile focused infrastructure.

Lot's of relatively low density places in Europe, Japan, etc. have very functional public mass transit. It's not universal, but there are good examples.

If you start with the assumption that approximately everyone has a car, you can choose build cities in ways that only support that...
What's wrong with HHVM? Honestly asking, I have no real context beyond knowing it is a FB invention
No, robots.txt is for well behaving bots like bing bot and google bot, not bots that will spam your forums (and Git repo apparently).
Louis XIV Was the Smelliest King of All Time
Shortcut keys are configured in the compositor, and screenshots/screencasts work in a cross-compositor fashion via xdg-desktop-portal.
I don't think the policies are racist given that:

1. white people with non-Western passports largely have the same formal hurdles to meet as the non-white people with the same passport

2. non-white people with Western passports largely have the same [lack of] hurdles to meet as the white people with the same passport

But the policies do certainly approximate racism since Western countries are predominantly white and non-Western countries are predominantly non-white.
This exposes one of the weaknesses of C and C++. Nesting functions inside functions is actually a very useful thing to avoid precisely what's described, while still allowing code to be more readable. The inner functions can always be extracted later if deemed appropriate. So if C permitted it you could do something like:

void FullUpdate(...) {
void PartialUpdateA(...) {
...
};
...
}

So that function is only visible in this one scope, but where it's used it can have the effect of greatly improving readability (especially if it's called multiple times).

Now, C++ can halfway get there with private methods in classes. So anyone outside the class has to really try to break that encapsulation and access the function. C and C++ can get there by not exposing the functions in headers, so they remain file local.

But that doesn't prevent something like (within a file):

// should only be called from FullUpdate
void PartialUpdateA() {...}

void AnotherFunc() {
...
PartialUpdateA();
...
}
People are already comparing individual models with and without self driving features to adjust for things like visibility. As these cars already have those driver assist features having them become more commonplace isn’t going to change the relaxant statistics.

That said, unknown future forms of driver assistance might be relevant, but I would lump that in with better cars.
X11 is a window system. An X client is an application that uses the X protocol (e.g., Firefox, GIMP, LibreOffice) while an X server is an implementation of the X protocol that handles the rendering. Note that an X server and an X client don't have to run on the same machine; if I log into a remote server and execute LibreOffice, LibreOffice is still the X client and my machine's X implementation is still the X server, despite the fact that LibreOffice is running remotely.

XFree86 is a specific X server implementation, though it has been superseded by X.org sometime around 2004 due to a license change from the MIT license to the 4-clause BSD license, which is incompatible with the GPL. X.org is by far the most dominant X server implementation in the free open source software community, but it is not the only implementation; off the top of my head there were proprietary X server implementations for SunOS and NeXT.
>> Ghost roads didn’t demand a massive mobilization of government. The technology of autonomous driving would roll onto existing highways, invisibly weaving a new transportation system. Only this one would be modeled on the Internet. Computers would outnumber people. Code would call all the shots.

Mmrright. Imagine a future where anytime public infrastructure stops working you have to contact Google's tech support. Just think of how that turns out today, when Google's algos decide someone's app is violating TOS or something similar, like the news that comes up every once in a while on HN, where the victims are met with a wall of automated messages that explain nothing.

"If you want an image of the future, picture a human trying to get through a bot to a human operator for ever".
For Fedora, the kernel version is always "the latest with a lag of a couple of weeks". All the currently supported Fedora releases update to the same kernel version at the same time; currently, both Fedora 32 and Fedora 33 (and Fedora 31 if you're still using it) are using kernel 5.8, and when Fedora 33 updates to kernel 5.9, Fedora 32 will update to kernel 5.9 too.
This seems like a general argument against product reviews.

The manufacturers are surely going to track the results of these tests and try to improve their rankings. Publishing the results doesn’t prevent that, it just gives consumers that information too when they are making choices about what kind of car to buy today.

Keeping test results private wouldn’t be consistent with the Consumer Reports mission of informing consumers.
We use mocks a lot on my team, and I don't think we've ever seen what you describe. Maybe you're using mocks incorrectly?
I always really liked Avdi Grimm's "Confident Code" talk: https://www.youtube.com/watch?v=T8J0j2xJFgQ

It has similar conclusions, but does it from the frame of the "story of the code" rather than abstractions like "functional core" vs "imperative shell"
People wanted a decentralized GitHub. That's why they built it like GitHub, except decentralized.
If you think Gitlab’s a Github clone you must not have seen Gitea.
The Asian vs. the Euro-American model.
You could not be farther from the truth. Gitlab is an improvement on Github in every way, they offer a suite of features that Github doesn't have that are only available through third party connections.

Gitlab is not a Github clone.
I feel like there is a perverse incentive for FB to police it’s content in a very un-stringent manner, due to the fact that more content = more means of holding its users attention. Like yeah we know there’s some bad stuff on our site but ugh taking it down would lose some viewers attention and cost us money... hmm maybe we’ll pretend we didn’t see it
Yes, massive issue and it's only getting worse as spammers leverage ML/AI to try and bypass firewalls which makes false positives test on legit emails.
> 60% of Americans having some idea of the issues he raised

His comment says an idea of "who [Snowden] was", not of what he was trying to say.
Both are just fancy wrappers and tools built around GIT. It's not surprising that one looks like the other. Given historic exoduses from one, it's only logical the other would build a similar toolset with the intention of allow for easy migrations between platforms.

While similar, the companies are different in the approaches, the platforms are different in their pricing (both having impacted the other which ultimately has helped consumers).

Your argument would hold true of any word processor. I think it's an unfair assessment of two products targeting the same specific users.
The DOJ is investigating Visa’s $5.3B bid for Plaid on antitrust grounds
I had discovered this recently too and asked a relevant StackOverflow question about how people deal with lots of I/O.

https://softwareengineering.stackexchange.com/questions/4160...

The premise is the imperative shell can become pretty riddled with decisions if your application contains a lot of I/O.

Some like the "Free Monad" solution, but I found that too be too coupling.
I've observed parking enforcement using a wax stick to mark tire and curb, or pausing to write tickets when already marked and aligned.

Probability of the marks remaining and aligning midday next day if the car was gone overnight seems vanishingly small.

Low tech, maybe not definitive, but still hard to argue with.
Common Misconceptions in Machine Learning
This is actually an extremely important point.

Because Wayland pushes so much logic into the compositor, there's now the very real likelihood that things will work on Gnome but not KDE, or work in i3 but not Gnome.
Writing is a technology. It's disputable if any technology is inherently neutral or not:

“One of the most dangerous things you can believe in this world is that technology is neutral.”

from https://thecompassmagazine.com/blog/is-technology-morally-ne...
Jack Dorsey Squares Off Against Ted Cruz
Sounds not necessarily bad were Google something open source or on-premise hosted.
In your circumstances I'd skip Rust altogether and focus on what the industry's using and what your colleagues are using. This will most likely be C or C++. If you go for C++, you can also use it in other domains, such as data science.

Rust is something you learn if you want to get a job doing Rust or for your general knowledge, not if you want to solve a problem or understand an existing domain.
While things like this are valuable, it still places the onus on consumers to change their behavior to combat climate change. Not until large polluters are charged for their carbon production, or are compelled to contribute to carbon removal will this have a net benefit. This is conscience-friendly capitalism at best.
You miss the point.

The problem is not wayland. I root for wayland and I hope it'll progress steadily to maturity.

The problem is getting pushed to drop my well-working Xorg-based setup for some wayland-based setup that can't run the application I use daily and that I've been running for years.

I'm okay with wayland, but I have a problem with people telling me "oh just drop that".
That two services based on git have git in their names seems reasonable. That's the only commonality... "hub" and "lab" are both one syllable, but very different in sound and connotation.
Giving money is making yourself feel good. Whether that actually achieves anything is another question altogether.

But giving money to achieve something is difficult because you need to invest time and effort to investigate where to give and to whom.
Microsoft will slowly kill github
> That said.. Maybe there is some equivalent for ESP32? I'm just not aware of it. You can do some other cool stuff with ESP32s. Like run Micropython and Javascript. You can also have wifi and related interrupts on one core and realtime stuff on another core (though I haven't exactly figured out how you'd set this up without using an RTOS)

To shamelessly plug my own project I've been working on to bring Nim to the ESP32: https://github.com/elcritch/nesper/

For an async http example see: https://github.com/elcritch/nesper/blob/master/esp-idf-examp...

Nim's async for networking is all there. ESP32's use a modified FreeRTOS with LwIP which Nim has OS level support for now. So Nim provides async http, json libraries, etc all in a about an extra 100kB of flash memory! IMHO, Nim has a nice Pythonic syntax but still lets you do low level real time code. With the ESP32's you can create "tasks" and use either events or data queues (see `rpcsocket_queue_mpack.nim` in Nesper).

Caveat emptor, Nesper is a wrap of the native ESP32 libraries. There's still bugs in wrapping the various apis, but mostly simple ones. Also I'd like to setup async for interrupts...
Thanks for this. I've had to just make it a habit to adjust the time anytime I boot into windows.
Is Companies House's website not done by GDS or something? I worked on a few GDS projects for DFT, we had to have independent pen testers test our services before they moved between phases.
> The idea is that optionals allow you to pass optional data by value.

Yes, and kj::Maybe was doing the same before std::optional was standardized.

It's disappointing that the committee chose only to solve this problem while not also solving the problem of forgetting to check for null -- often called "the billion-dollar mistake".

> Dereferencing null optionals is UB for consistency with dereferencing pointers. All uses of operator* should have the same semantics

My argument is that `std::optional` should not have an operator* at all. `kj::Maybe` does not have operator* nor `operator->`.

> If you want to dereference an optional that may be null, use the .value_or() method. For the times when you absolutely know the optional has a value use operator*.

This is putting a lot of cognitive load on the developer. They must remember which of their variables are optionals, in order to remember whether they need to check for nullness. The fact that they use the same syntax to dereference makes it very easy to get wrong. This is especilaly true in modern IDEs where developers may be relying on auto-complete. If I don't remember the type of `foo`, I'm likely to write `foo->` and look at the list of auto-complete options, then choose one, without ever realizing that `foo` is an optional that needs to be checked for null.

In KJ, you MUST write:

KJ_IF_MAYBE(value, maybeValue) {
use(value);
} else {
handleNull();
}

Or if you're really sure the maybe is non-null, you can write:

use(KJ_ASSERT_NONNULL(maybeValue));

This does a runtime check and throws an exception if the value is null. But more importantly, it makes it really clear to both the writer and the reader that as assumption is being made.
That's the simple case. When it's a big chain of injected dependencies and you have to untangle the whole thing, it gets annoying quickly.
it depends on your needs. if a single log line is sufficient to log all the information you need to do your debugging then Loki is a great choice.

if you need to see the full request as it passed through your system then distributed tracing/Tempo is a great fit!
I've had the "please turn off your zoom camera if you're going to floss your teeth on a call" discussion. (Was using his own zoom video preview like it was a mirror so everyone got a good close-up.)
GitHub and GitLab, Gitea etc are all centred around git, so including "Git" in the name seems like an obvious, sensible even, idea.

Personally I don't think the GitLab UI looks that similar to GitHub's, and to me it looks and feels kind of clunky, and lacks contrast.
That's interesting, but if you follow the citations, you'll end here [1]. And in that paper:

> The Night return includes split-adjusted dividends as reported on CRSP.

So, uh, that's a pretty big reason for night returns being higher.

[1] https://papers.ssrn.com/sol3/papers.cfm?abstract_id=1004081
Having used both stricter (Rust) and more loose programming languages (JS), I can add that stricter APIs have made me think more about edge cases than the less-strict APIs. In the less-strict languages I often find myself debugging some edge case, whereas in the stricter languages I am more often required to think about edge cases up front (including those that I know will not be relevant, so in some cases this causes more work than necessary!). Still I much prefer the stricter APIs.
You call them realists, I call them misleading marketers.

The term to use is driverless. Gives the correct idea of what users imagine. All thsi "self-driving" or FSD is just driver assistance given more capability with no regards to safety.
Should I Start a Business? Why
That was easily some of the best bang-for-their-buck my parents ever got. LEGO Mindstorms would keep me quiet and out of trouble for days at a time.

I'm not certain how much that influenced my interest in software engineering though, or even if it made learning traditional programming easier. I later had a few c++ courses in high school, and as I recall most of my struggles were with syntax errors (not discounting those in the slightest because I made a _ton_ of them) and whatnot rather than some kind of broken control flow, and I remember that not being the case for all but two of my classmates, so it does seem plausible that some of the Mindstorm lessons stuck around or shaped how I think about such things.
Docker’s developer pivot is hitting the mark, executives say
A scalable, full-stack live quiz framework built with VueJS and Node.js
“You’re not owed anything,” from the developers of a flailing project to its users, is a red flag.

Those users are the target market that those companies are interested in pleasing. It’s not about “owing” or not. It’s about delivering something that people want to use or not. If you fail, the users will go elsewhere. You don’t have to care; you might develop the software for your own personal gratification. But people are going to share their dissatisfaction and might very well vote with their feet. And it’s possible that, even if they don’t, your work makes the world a worse place. No, no one can sue you or call you a cheat for doing a bad job, but they don’t have to like it either.