skysight-inc/HackerNews huggingface dataset:
>The people who do this usually screw their teammates more than the company. Big companies don't suffer if random people are slacking off and refusing to do their work, but their teammates who want to get a promotion or build their skillsets are going to suffer the consequences of deadbeat coworkers.

??? You've got it exactly reversed. Slacking coworkers are the company's problem, not yours.

I've never seen any company decide not to give a promotion to somebody because their coworker was useless. Hell, sometimes the useless coworker helps because it makes them look better by comparison.
> What's the advantage? Forking processes is more heavyweight than a typical function call, but that's hardly a concern if the use case is a REPL.

I was wondering the same thing, to be honest - if you're in a REPL, does it matter that it takes 200ms to "call" a function than if it takes 20ms?
Ah, so close... the roofs in my area are all reddish-brown and a different color will clash with the local conservation area constraints. But maybe by the time I have to replace my roof (which is soon) they might have the right color.

Hum, thinking of it, there are solar panel exceptions to the constraints, as long as they are flat on the roof...
Even with own products it often is an issue; after years of working on something complex, you want or need to launch it. But it might still be quite bad compared to your vision of it; you simply run out of time, steam, money etc and launch it. Tests succeed and with ok coverage, you even have some tla+ and coq covered parts, but, because you have to be somewhat practical you stopped proving things (or even just dropping some less uphill practices) years ago.
XML was supposed to be a silver bullet of the myriad of ad-hoc formats for structuring documents that existed in the wild pre 2000(I got this information contested here, but that's what an old professor told me).

In the XML "stack" you can find the XSL to ensure the validity of an XML document, the XPath to be a querying language, the XSLT to be a language for writing transformations, etc. I think one must at least respect XML stack vision of coherence and completeness.

Then you have things like JSON where the whole wheel is being reinvented, in my opinion, for no clear purpose. You have for instance hundreds of libraries for creating a JSON schema and everything looks like a waste of time overall.

Before anyone asks me, yes I have used JSON and YAML and I never could really understand why people keep recreating basic stuff like markup languages instead of sticking to whatever is available. And yes, verbosity because of the XML tag system always sounded a pretty silly argument to me.
> if you have 5 devs does your team have 4-10 items in flight usually? if so that’s a team on the slow and steady path. if you have a team of 5 and you all work on the same thing at the same time then the pace can be really quite impressive.

This sounds like a good heuristic. Can you expand on that?
Radicale: Small but powerful CalDAV and CardDAV server
And coffee was spilled! Well played!
> There is no laptop that I can buy today that is equivalent to an M2 MacBook Pro at any price point let alone significantly cheaper.

Why are you comparing with an imaginary equivalent? Different things matter to different people - dimensions, weight, battery life, raw power, extendability, screen. There are a bunch of options that beat M2 Macs on all those bar battery life - e.g. my personal Asus ROG Zephyrus G14 is better for the things that matter to me than my work-issued M1 MBP and it's not even close - a screen that doesn't cause eyestrain within tens of minutes, choice in the OS, similar dimensions, much more raw power, extendability, repairability. The only thing in which it's worse is battery life. An LG Gram is lighter than an MBA/MBP, and goes to 17'' for the screen size.

Don't get me wrong, MBP hardware is pretty good. The problems are lack of choice (like screen type), highway robbery when buying extra RAM/storage, and a nearly total lack of repairability and fully total lack of extendability. Oh and a pretty subpar OS.
Just to clarify, it is not just about "hidden" files looking good. There are many reasons one may want to move config/data/cache files to other locations, E.G. in my case I have a computer with home on a small partition that simply can't fit all the crap those misbehaving programs try to put there. I simply can't install Flatpacks on that machine because they obviously won't fit in a small home and can't be moved because of a maintainer who is very disrespectful to users (the bugs full with messages of users pleading for him to allow them to move apps to other partitions is disheartening).
Co-routines are available in C++20. And in dozens of other libraries, if for some reason OP is limited to < C++20 which I doubt considering that the product is not yet launched.
Whoa, tried https://vocalremover.org/splitter-ai on a couple tracks and it sounds better than Spleeter, Demucs and Serato. What model do they use?
Gitflow is more complex for sure (although there's less-complex alternatives that work just as well, but that aside), but it's with reason and allows for parallel maintenance of released versions in more traditional applications where multiple versions may be alive, e.g. non-evergreen desktop applications and server software.

It's added complexity and it has a cost, but there are good reasonings for it. Trunk-based and not-gitflow is fine for SaaS services or web applications I'm sure, the things that CAN be deployed in a continuous deployment fashion.
[factorial joke]
XML itself is a pretty focused spec. XML schemas and the whole SOAP stack is where it went off the rails.
> Writing code that other people understand is an independent skill

It's also the main skill of a developer. Code is for people.
Thanks for that longer (and gracious) explanation.

Upon a more careful re-reading, your post is more clear; I chalk up my misreading to reading and replying while commuting back home from the airport. The fault is in my reading not your writing.
Last time I checked (October 2022) ~11.7k out of 18k Ukrainian Starlink terminals were bought and paid for by Poland.
If you imagine a log file that gets lines added to it now and then, its actually quite fiddly to do that with XML because of the closing outer tag
Except the copyleft‐licensed projects have the legal means to prosecute, if they so wish to do so.
With a claim like that in the title, I would at least expect a comparison to other electromechanical games and a discussion on why this would be the most complex one.
Government: if you think the problems we create are bad, wait until you see our solutions.
Mandatory setup wizards was really horrible and a throwback to the UI design of the late 90s. So modern!
Who knows certainly? We would need to buy them them all.

Even if not, they are clearly waiting for others to do the needful for free, and then gladly recoup the fruits of others labour while selling their compilers for profit.
So, for my own projects in Go lang, I created a simple library for loading configuration files, so it can load configuration either from .toml files, or from .env files or just from an environment variables.

Then you define your config like that:

type ServerConfig struct {
Address string `env:"HTTP_ADDRESS"`
Port int `env:"HTTP_PORT"`
UseTLS bool `env:"HTTP_USE_TLS"`
CertFile string `env:"HTTP_CERT_FILE"`
KeyFile string `env:"HTTP_KEY_FILE"`

Timeout int `env:"HTTP_TIMEOUT"`
}

type Config struct {
Server ServerConfig `env:"SERVER"`
}

So, for example, with the code like this:

if err := config.LoadToml(&cfg, tomlFileName); err != nil {
return nil, err
}

if err := config.LoadOverrides(&cfg); err != nil {
return nil, err
}

It can load from TOML file, and from environment variables. This means - service can be either started from container, or run locally with .toml file.
Adding to the great points already here, decentralized production makes the system more robust to accidents, terrorism, and war. Not immune by any stretch, but more robust.
So in other words, all the telecoms are systematically lying to the FCC in order to steal money from taxpayers, but there is no actual enforcement nor penalties for doing so, so they continue to do this with impunity.

(I remember when Clinton gave away a huge giveaway to the telecoms so they would provide fibre everywhere, and then they did fuck all and just laughed.)

In a just society, they would quickly be presented with a estimated bill for the largest amount that they could possibly have stolen - I'm sorry, let me repeat this word "stolen" - from the US taxpayer, PLUS massive penalties, and then they would be required to prove how much they actually stole if they wanted to reduce the cost.

Plus complete discovery of all their records should be required, with a view toward criminal prosecution of their executives.

As it is, they have absolutely no reason not to cheat, lie and defraud if they think they can make money at it.
Sorry, aren't these "validators" part of the network? They run the network, don't they? The money that they get paid is therefore revenue, not a cost, from the standpoint of the network.
Yeah, they like to hide this, but well know that they are required to provide warranty. One of my iPhones had discoloration around the screen edges and I bought it more than a year ago. They repaired it no questions asked.

I think in such cases the 'burden of proof' is fairly light. There is no easy way I could have caused the discoloring, except if the phone became wet (this was before iPhones were water resistant) and they could easily see this with the water indicator strip.
That’s the first thing they notice. Watch further.
What's the overhead of an unique_ptr vs the equivalent rust pointer (yes yes, I know that the Itanium ABI has non optimal calling convention for unique ptrs, but I would be surprised if you can measure it)?
The other aspect is latency, even streaming from a wired ethernet connection to a wifi phone or tablet makes platformers especially feel frustrating to play
Guetta is not saying it's the real deal. The creativity, is his usage of the tools available. He could have hired an impersonator, it's the same thing (in my opinion).
Locally in your browser, too. Footer:

> Image processing is done in the browser. No image data is stored or transmitted.
> I am specially concerned about throwing away months worth of code. Rewriting everything from scratch is what newbies love to do and will most likely get you in the same mess you were in.

This was my first thought, but then I realised newbies would have started with Rust. :)

In the first few months of a big build a huge amount of time and effort goes into the foundation: design, POCs, setting up environments, CI, testing infrastructure…

My guess is that they weren’t very deep in production code, and the fact that they didn’t fall for the sunk cost fallacy speaks highly for them.
Cold-Food Powder (an ancient Chinese drug)
No, the rate of accidents with Bonanza was found to be caused not by any defect of the airplane, but the high performance airplane-low pilot skill combination. It was a had too big for many people.
They're not doing anything illegal. What is the leverage?
There is a very big difference between putting out a record and playing something at a performance. The latter is a lot more lax.
You could have named it "drama screen".
I have only been offshore once, in the Goliat platform, for a mooring monitoring system installation — I was definitely not expecting the cruise ship like crew quarters! Single cabins with ensuite bathrooms, a cozy dining room with wall to wall windowing, even a pool table!

Goliat is a very modern FPSO design, however. My colleagues' experiences in other floating rigs around the world, which are usually built from converted tanker hulls, are more like what you describe, especially below the equator. For contractors you might be lucky and get a double cabin to share, but cabins might have up to four bunks. Definitely don't forget to pack some flip flops or crocs for the showers!
>Rust is not difficult because of lifetimes, it just gets in the way of freely prototyping what you want.

I'm not a rust programmer, but I guess that's an issue if you come from a dynamic language, not from c++.
I'm writing (as a side project) a game with a client-server system.

For the server, I'm using dot-net's SslStream (in TLS mode) and it needs to know which TLS cert to use prior to handing over control of the connection.

For this reason, I've designed the protocol for the client to announce who they are and what they want as a single line of JSON before letting SslStream negotiate TLS. Once the connection is secured, the client repeats that first line of JSON. If the server detects any difference between the two it closes down the connection. (I also made sure to clear the buffers after reading that first line of JSON.)

I don't like doing that but the only other way is to "roll my own crypto" which I understand is a bad thing.
Because worse is better (which i mean in the unix sense of the phrase).

On the specific subject of schema, i think most of that is most users have no need or interest in a schema.
To be honest golang is amazing for dbs.
Nobody is doubting that transactions aren't worth what people pay for them. The doubt is whether the fees that users pay exceed the costs of operating the network.
Sounds similar to https://github.com/spf13/viper
How does this compare to age: https://github.com/FiloSottile/age ?
Projects going stale is a cross-language problem really. Rust will also encounter this at some point.
> XML meant that I'd have to figure out the tag soup that the developer had chosen for their XML data

There was DTD for that but probably rarely used.
Not really. I stream wirelessly with Moonlight (NVIDIA software streams on my PC) and it’s not noticeable at all, even for shooters.
same, but I want one of the upcoming colored transparent backplates, the purple one looks great.
If fees are thrown away you can't count them as revenue. Also, still no mention of costs.
Same here. Reimplementing something with a weaker license is not a friendly behavior.
1. It doesn't separate program's config, data, and cache; so it is impossible to backup excluding cache, impossible to reset your config without data-loss.

2. It assumes home is infinite, if you are running out of space in home you can't move program files to other partitions. E.G. Flatpack hardcodes its apps data in `~/.var` so if you have a small/almost-full home partition you simply can't install certain Flatpacks.
10 years ago "use a strong password with all these symbols"

Average person reluctantly moves from 123456 to P@55word!

8 years ago "no passwords such, use a pass phrase"

Average person reluctantly moves from P@55word! to correct-horse-battery-staple

6 years ago "ok but you need to use different passwords on each site"

Average person reluctantly moves to different passwords per site

4 years ago "but you can be phished, you have to use 2FA"

Average person reluctantly moves to SMS

2 years ago "no in some countries it's easy to take over SMS, use TOTP"

Average person reluctantly moves to TOTP

Today "no TOTP is rubbish, you can be phished, use this hardware authenticator"

Normal people don't like new shiny ways of working every year or so. My house's front door lock is broadly the same interface as my great-grandparent's front door lock, but technologists think changing the way things work every couple of years is acceptable.
Well... There is nothing stopping you partially parsing an XML documents. What you can't do is validated it. Which is the same for any other file format. You be sure the file is fully valid without fully parsing the whole file.

However, the only order you can partially parse an XML file is linear order, which clashes badly with the fact that it's a tree based format. Depending on how tree-like your schema is, this might be a massive hinderance.

This flaw isn't unique to XML. All text encoded file formats share this characteristic, and can only be parsed linearly. If you move across to the world of binary file formats, it's extremely common for them to have indexes of offsets so a parser can navigate a tree-like structure in tree order without having to fully parse it, along with other types of non-linear data structures.
Several things come to mind. First, you don’t need to remove viral DNA from cells. Just make them over-express HIV and trigger cytotoxic lymphocytes or antibody-mediated killing. You end up wiping all the infected cells. But then, of course, patient is left with compromised immunity. To solve this, you could make a stem cell transplant from a compatible donor. Alternatively, harvest healthy cells before the treatment and transplant them back after.

This is from the top of my had, I’m not an expert in the field.
I agree. I'd actually pay if it could do this in addition to its current set of features.
> ....since C++11 there is no reason for not using smart pointers.

Sadly there is, lack of security culture and plenty of devs won't allow them on a PR.
> However C++ smart pointers impose a run time performance penalty on your code.

i'm not sure if this is the case. unique_ptr doesn't really do much other than use the type system to ensure that only one instance of the pointed-to value exists at once. as far as i understand, it doesn't strictly do anything at runtime.
How to exploit: For imap or smtp one can construct commands that will lead to a mail with the login credentials being sent to the attacker (assuming the attacker has an account on the same server). For POP3 we were unable to come up with such an attack, as it has no way of storing or sending mails.
Google Street View running over a motorcyclist
In practice in many services 2FA is about hoarding PI to target ads, not improve security. I don't buy into that.
s/just/exactly

But 'Interesting. Please continue?'
There are a lot of very good answers already in this topic:

- quality doesn't bring enough to the business value;

- high demand requires hiring people without enough knowledge/skill;

- other people have just different quality metrics than you;

- "know-how" transfer between generations is difficult...

IMHO the similar question may be asked about any domain of life: why not all the buildings are well-built? Why the political/social systems are not just? Why good art is so hard to spot nowadays? They have different answers, but there is one common theme: building "well" is difficult; creating a "just" political system is "difficult", creating a good art is difficult; also writing "useful and reliable" software is difficult.

It's only natural that not everybody is a perfect software engineer, therefore is not a surprise that not every software will be perfect. What's more, there are a lot more mediocre software engineers than the perfect ones, therefore the majority of software will be... mediocre. The same about art nowadays — the sheer amount of music produced (even the word "produce" suggests it) every day makes sure that, in overall, there is a lot more terrible music compared to good compositions. I believe that software engineering has the same issue — the rising number of software projects is an enough explanation for low quality of the software we are able to perceive.

In fact, I don't believe the quality of the software engineering degraded over the years, but it's just more difficult to spot the great projects in the avalanche of "normal" life.
I think the true lesson of xslt, is xml makes a terrible syntax for a programming language. The language itself minus the syntax is fine, although i think many people prefer a more imperative approach.
Not only legal: 100 countries makes close to 100 different ways of taxing stuff, e.g. different VAT rules. Different rules for what must be specified on an invoice and how often you must invoice customers.

So finance part also gets really complicated.
Indeed.

Also seastar comes with coroutine supports[1], and incidentally it was written for a very high performance C++ database implementation.

[1] https://docs.seastar.io/master/split/5.html
I'm not sure what your point is, the recommendations improve and evolve over time.
If 30 years ago you could fly a brand new plane for a price and now you can fly a 30 year old plane for a lot higher price, he is right to complain. It is the same comparing the price of a new car 30 years ago with the price of that used car now, with half a million miles on it, ignoring the potential "vintage, mint condition" surcharge.
So the cost of storing all the data and doing all the computations is only $5k/day? Where do you get that from, if I may ask?
Sometimes I just don't really see it as a competition. For my research work often XML is a markup, which JSON is not. If I want to qualitative code a text, this is perfectly doable by hand:

<note>
<paragraph>This is a <code vibe="positive">remarkable</code> text.
</paragraph>
</note>

If you do it in JSON, it is not really readable anymore, and I would have to write GUI for the input, e.g.,

{ "note":
{ "paragraph":
[ "This is a ",
{ "code": [ { "vibe": "positive" }, "remarkable" ] },
"text."
]
}
}
This is a great example of one of the many many real-world uses of cryptocurrency that has (likely) been made illegal by regulators.
Others have: https://wp.usatodaysports.com/wp-content/uploads/sites/88/20... - ok, this cheats a bit, because it uses a king penguin instead the larger emperor penguin...
I actually didn't realise the spec was so young. I started using the internet around the same time as it was finalised. It's something you just assume has always been there.

XML has its issues and personally I am always happy when I am dealing with an API or data source and see JSON rather than XML. However, there are a lot of cool things built on top of it. RSS is an obvious one that pretty much everyone here will appreciate. GPX is another really useful one. A lot of financial reporting is now also being standardised using XML. Even derivatives trading: https://www.fpml.org/