skysight-inc/HackerNews huggingface dataset:
Well, what's true is that if you leave it to the application, you now have two problems: you have an RDBMS you use half-way, and an app that needs to implement the RDBMS features that you're not using from the RDBMS. Since most app devs are not RDBMS devs and don't want to be, they're bound to get a few things wrong.

The most likely thing to go out the window in an ORM-type app is concurrency. Take a big lock around DB ops and you're good, right? But then, too, there goes performance.

Or, if it's not concurrency that goes out the window, you have to implement eventual consistency...

The worst thing I've seen too much of is application-level JOINs and such. Next are recursive queries: done in the app. All that absolutely destroys performance. Then you have custom query languages that are just never good enough.

So I am mostly in agreement with you, but "b.s." is too strong for me. You can get all of this right in the app, though at a terrible cost, and there are times when maybe it's actually for the best.

Let me give you an example of how I might build something that's somewhere in the middle. Think of Uber or Lyft. I might have a single widely-replicated RDBMS for users, and maybe another for drivers, and maybe per-city in-memory-only ride DB for tracking requests and current rides, and one more, possibly sharded DB for billing. The ride DBs would send billing updates via some pub/sub scheme (e.g., like PG's NOTIFY, or something else). Recovering from reboots of the ride DB is easy: rely on the apps to recover the state. Most operations only have to hit one DB at a time. The whole thing is eventually consistent for user/driver ratings and billing, which seems rather fine to me given that the operations to synchronize are essentially just aggregation updates. In such an app there's not a lot of room for application logic in the DB -- some yes, and I'd put as much as possible in the DB.

There are plenty of apps where some degree of eventual consistency makes sense. What doesn't make sense is to end up hand-coding JOINs, GROUP BYs, and so on. And my preference is to use FKs and triggers as much as possible, but within limits (see all the above).
Aren't some modes of transportation less sensitive to overall capacity or weight?

I can imagine trains can be extra heavy, and scooters might require less overall energy capacity.
> My personal feeling is that I'd rather pay with my time by watching ads anonymously than pay with my personal data.

And with cable type commercials being trivially skippable with fast forward, that's another reason it's the best programming format as far as being advertised to is concerned.

Because ultimately, you're never going to get away from being advertised to.
Its not a good thing. Like electron or not, apple needs to have very good reasons for blocking libraries.
You aren't Facebook. Facebook has put massive work into adding layers on top of MySQL that your startup has not.

Also, you seem to be forgetting PostgreSQL
Eating bone marrow played a key role in the evolution of the human hand (2018)
Yeah, conjectures. I think I got mixed up because there's a theorem about the non-trivial-conjuectures-are-unprovable thing :)
Slower compilation doesn't mean slower execution. Scala has "Native" and JVM implementations with different performance characteristics. Scala is a hybrid that allows imperative code with a lower level of abstraction than Haskell, closer to hardware. Thus it is potentially more performant.
> The first thing that is needed or this to work, is for the part of universe representing the human to be separable from the rest of the universe

What do you mean by 'separable'? Humans are a product and part of the universe.

> This separability would allow to talk about choice, as it allows to modify or swap the human in question and recompute the future in the same universe where the human may make another choice.

I'm not sure what this shows. If you swap the human for a different one then you would expect a different choice. If you can't 'recompute' the exact same universe with the exact same human, that also doesn't show anything other than your inability to recompute.

> If this is true, you may be able to easily predict some of the choices human will make based on his state several seconds before that, but for longer time intervals the only way is to let the human live and make the choice (even if it lives in your computer simulation).

The fact that we can't perfectly predict what a human will do doesn't mean there is free will. It just means we don't understand the system enough.
This was really interesting to read, since I'm about to rebrand my own startup. The stakes are a lot lower in my case, but hopefully it doesn't turn out like this.

I'm going to rename FormAPI [1] to DocSpring.com [2]. I'm also launching a new website, and you can see a preview on my staging servers [3]. The main reason for the rebrand is that FormAPI wasn't a very good name. The service is an API for filling out PDF forms, but FormAPI doesn't communicate that clearly. People would often spell it incorrectly, and I got tired of explaining it to people.

I also wanted to move to a decent .com domain. "FormAPI.io" feels like a small side project, and my theory is that "DocSpring.com" will feel a bit more trustworthy. (I'm still a solo founder with a small company, but I recently raised a small round from Earnest Capital [4], and I'm still around after 2 years [5]!)

I think I'll be launching the new site tomorrow, so wish me luck! And please let me know if you have any feedback about the new site (or in general.)

[1] https://formapi.io

[2] https://docspring.com

[3] https://staging.docspring.com

[4] https://earnestcapital.com

[5] https://news.ycombinator.com/item?id=15427891
> if CoC's were inherently politicized statements

Aren't they, though, if it happens that what CoC's say align much, much more with one political group than another? This obviously implies that the latter group believes in conducting themselves quite differently than the code mandates, and they need to suppress those beliefs (or at the very least, not act on those beliefs) while engaging with the group whose code it is.
Back in college every student had some Microsoft email account. When a certain amount of storage was full you'd get spammed daily with "your storage is full" messages and because Microsoft's own emails were whitelisted they'd go over the storage limit of the mail account.

But 100000 emails is another order of magnitude.
True. Upbringing and parents can form a foundation, but reality can shake it, too.

I voted solely for Democrats in every election (local, state, federal) from 1980 until 2012. By then, though, the party I had always supported was telling me that I'm inherently racist by consequence of being a middle-aged white male; that I don't pay may fair share in taxes (though I do); meritocracy is now bad; capitalism is now horrible, most all problems are due to white males, ...

I found myself quoting Reagan, although I despised him in my 20s (many of us at the time believed he would lead us into WWIII). He said "I didn't leave the Democratic Party, the Democratic Party left me".
Being a consumer, you would be part of helping the market filter these out. I don’t want to help my grocer “filter out” spoiled foods too often. I’ll go to a grocer that filters a bit before stocking.
> 4) use private APIs to be competitive with Safari on things like power consumption.

Uh, if that's the case then I think they're barking up the wrong tree. Just given. How that's going for them.
One of my favorite papers. Incidentally, although I'd spent my entire career chasing some elusive notion of "good design", this paper was the first I have seen to explicitly define "good design" as "modular".

It is now generally accepted that modular design is the key to successful programming... However, there is a very important point that is often missed. When writing a modular program to solve a problem, one first divides the problem into subproblems, then solves the subproblems, and finally combines the solutions. The ways in which one can divide up the original problem depend directly on the ways in which one can glue solutions together. Therefore, to increase one’s ability to modularize a problem conceptually, one must provide new kinds of glue in the programming language. Complicated scope rules and provision for separate compilation help only with clerical details — they can never make a great contribution to modularization

I now tend to see all the other design principles as ways to improve modularity. Everything else is mostly just fluff.
Ahh, but what is your answer to both of those then?
Having a favorite competitor is fine. Having so much loyalty to that competitor, however, is cultish. What happens when you get tired of that competitor, and some other competitor is offering something better? Or your favorite becomes abusive and you want to move? By supporting that competitor so strongly, you've encouraged monopolistic behavior, and now you're going to suffer for it, because there won't be good competitors any more, or you'll have a very hard time freeing yourself and migrating to the competition.
That is all just nonsense.

You don't have to use Swift as there are plenty of alternatives many of which run on Windows or Linux. So in theory you could do all your development on a non-OSX platform and then just use one of the Mac hosting providers for CI/CD.

And you don't have to give Apple 30%. Just notarise your app and add a link from your website.
> Grunting and stinky subhuman

You're just describing me in the morning.
> In lots of cases going for the very long term scalable solution will be an impediment to your growth, and I'd suggest dealing with those issues when the chance that you need them is on the horizon, rather than across the globe.

My favorite example is a bootstrapped startup that I co-founded. We had a couple thousand users and less than a gigabyte of data. The app was a run-of-the-mill CRUD app. I built the entire back-end API as a single service that could be built and deployed on heroku in minutes.

At some point, I left the project, and my co-founder hired an expensive consultant to review the system and provide feedback. One of his suggestions was to break up the entire service into a suite of microservices. And this was for a service that barely averaged a handful of active users at any one time. And a team of ~2 engineers working on the back end code. Microservices.
The performance impact is at write time, and having the data cached in memory is irrelevant. It's the locking overhead that's non-trivial, especially if each table has several FKs, when operating in a high-volume OLTP environment.

As for "database engines that properly support online schema changes without locking, downtime or table renaming hacks", please name some. In my experience, every major DBMS has cases where certain ALTERs block concurrent DML, which is extremely problematic on very large tables. Or even cases where there's no locking, but the operation still takes a very long time, which is conceptually problematic for logical replication.
I thought woods hole "serpedipitously discovered" a lot of stuff.
Coincidentally, I just wrote a simple JSON parser the other day as a toy exercise. A simplified snippet of parsing code (handling only arrays) relevant to the discussion here would be something like:

def parse(text):
stack = []
index = 0
result = None
while index < len(text):
char = text[index]
val = None
if char == '[':
stack.append([])
elif char == ']':
val = stack.pop()
index += 1
if val is not None:
if stack:
stack[-1].append(val)
else:
result = val
return result

Using the test utilities in the repo indicate that the parsing logic can handle arbitrarily nested arrays (e.g. up to the 5,000,000 max in the test script), bound by the limits of the heap.

It seems like the main criticism here is against recursive implementations. Or am I missing something?
'Image' versus Reality.

Some people are more concerned with displaying 'Image' than whether or not they can keep up with Reality.

This has been historically the difference between 'Old Wealth' and the 'Nouveau Riche'. The Nouveau Riche mentality is that if you have it, you must flaunt it ostentatiously. The people whose families have been wealthy for generations very often don't show it at all, or maybe they have some things that are 'very good' but 'old'. (To take that to its logical conclusion, think "a 40-year-old Rolls Royce".)

My sister always looks like she wouldn't have two cents to rub together, but she keeps several million dollars stashed away so that all of her (4) kids could be given a million bucks at any time if necessary. Note that if she can give it to one child, then she feels she should give it to all four as a matter of 'fairness'. Then again she has three houses, all set up with clothing and furniture and appliances, so that she just has to arrive and everything is available for her immediately.
Shutter speed yes, ISO... I think you can check the gain of the sensor used for an image, which is a similar concept. You can see this information on the FITS files ("the raws") metadata.
Just to clarify, you are saying Apple and Google are a co-monopoly because there is no third choice, or what? The link to Lerner index says it's pretty much impossible to actually calculate so I don't see where that's going.
What kind of safety critical system was it?
If GP is correct, that’s not the case. They are important APIs for someone who wants to maintain their cross-platform abstraction layer without muddying up their codebase.
Only when we will find new alternative the world will realize how reliable we are on Google and FB when it comes to digital businesses growth
It also doesn't work too well without Microsoft Windows.
I didn't quite understand the migration issue TFA talks about, but at least with PG, there's more than enough clever ways to make schema changes incrementally.
It's not (just) about language theoreticians pushing their favorite features.

It's mostly about regular programmers who have seen other languages and don't want to write the 30th new slice copy function, or the 10th get-slice-of-keys-from-map function. They might also not want to keep reading `if err != nil {return err}` over and over between pieces of logic in a function.
So if I'm reading this right, the master process can lose writes (if there's permanent failure). So taking your 2PC scheme above with the 'settled' flag, you can respond to the client that the txn has been committed once you've written the flag, but this commit marker can also just be entirely lost? (again, permanent failure)

If this 'settled' flag exists on each 'shard' instead of just the coordinator, any random subset of those too can be lost? I don't understand what's going on here, or what guarantees this 2PC implementation provides.
NoSQL got popular because Google needed it for their billion-user planet-scale system, and then a million startups pretended they were Google. As soon as Google built their planet-scale NoSQL system, they immediately started replacing it with a planet-scale SQL system (Spanner)
Nonetheless, $200-billion has been added to the money supply. (See FRED M2 Index link below from September 19 to the present)

$200-billion could have been implemented for more worthy projects than the repo market. In my opinion, the FED needs more oversight from Congress and/or the Treasury.

https://fred.stlouisfed.org/series/M2
Same here. Plus Windows/Total Commander
How can they sue him directly?

I thought that the company is kind of a 'shield' when it comes to personal sues
So in typical golang fashion, you have to manually reimplement exceptions, but in a worse way.
Well the HN home page doesn't validate in the experimental HTML 5 validator either ;). The validator's point isn't to cover the largest set of documents on the web out there (you could use my "mini"-DTDs for that) but to inform authors about less ideal markup (as in "HTML recommendation").
Read the CIA’s 1951 Listicle Comparing U.S. and Soviet Propaganda
Developers love tools, how about one for shopping? Please check out Mergie
When your differentiation is in your ecosystem how is this action independent of competitive pressure? Their customers are end users and the App Store is one (and how they've run it) of their best selling points.

Your line of thought only works if the developers are the customer- they are not in Apple's case.
This comment makes no sense to me.

How are Firefox and Chrome not competitive given that Safari isn't the overwhelmingly dominant browser ?
Or to put it more succinctly, life is path-dependent.
Hey guys, my good friend and I just launched a way for you to shop everywhere (Amazon, Best Buy, Target, Walmart, etc.) at once. One search for most online retailers. Think of kayak.com, but for shopping. Please check it out and please give us feedback. We both felt that this would save a lot of time while shopping online. While building this, we actually learned that there was something like this about 5 years ago, called thefind.com. Facebook acquired them for an undisclosed amount of money and shut them down. They were the second largest search engine (2nd to Google) before being shut down.
I think it's fun, but I HATE that it has such a strong pay to win component.

If a video game let players spend thousands of dollars on high power abilities to completely dominate the lower paid tier players, they'd be ridiculed in many circles.

There are certainly ways to play around this, but it's definitely a thing.
When it comes to Haskell, I want to add that especially when you start doing parallel programming, it becomes even harder to reason about. You might expect that doing that extra data type conversion in parallel rather than in sequence is going to make things faster, but you could find that the GC needs to do more work for whatever reason, and it ends up actually becoming slower. It's very counter-intuitive. It's a shame because writing parallel code in Haskell can be very elegant. If only the behavior was more obvious it would be so great.
A better question to ask is: Is it a success of CS education since developers know when to make tradeoffs in software engineering and go for the most easily understandable code (recursive implementation used in most pseudo code) since deeply recursive cases are rare, or is it a failure that software engineers cannot figure out how to convert a recursive algorithm into an iterative implementation for greater memory efficiency?
Adding postgres there and there where it's clearly the wrong tool is a bad advice.
Comparison of Soviet and VOA Radio Propaganda [pdf]
Interesting conjecture! I have seen whales with my eyes and heard them on sonar, and disagree with you.

Note that minimizing harm and preventing it are different things.
Netflix already limit the number of simultaneous devices playing and you can already pay more for more devices.
App Store will always be relevant since it's such a popular distribution channel.

And one app not being on there isn't going to change that.
> > FKs are a performance impact. The fact they require indexes is likely fine, since those indexes are needed anyhow. But the lookup made for each insert/delete is an overhead.
>
> You have to check referential integrity somewhere. You can do it in the application or you can let the RDBMS do it for you, but it will have to happen somewhere. So the overhead argument is kind of bullshit. Yes, managing the integrity in the app might provide more flexibility, but it comes with a price of, well, having to do your own integrity checking and introducing more bug space into your code.

Perhaps they meant "latency" rather than "performance". With eventual consistency you can have lower latency, and spend more cycles fixing referential integrity later.

Of course, sometimes things fail in eventually-consistent systems (e.g., you order some item from a vendor who claims to have stock but oops! they don't, so your order will take a few more days to ship than they claimed and now you're a bit sad but hey, it all works out in the end, right?).
"Software Sells Systems" used to be their motto and it's apt for how they treat the Mac and iOS. If the platforms don't have platform-specific apps, they become a commodity and lose those margins.
It seems like something they could easily verify: they know the exact location of the truck when the package is marked delivered. If it doesn't correlate with the delivery address then something is up. Another clue would be a bunch of packages marked delivered at the same time that don't have tightly clustered delivery locations.

I agree with you about performance metrics being gamed, wouldn't surprise me.
Except hopefully your customers do not have direct access to your backend.
Best error handling is Either aka Maybe aka Result.
The author makes some good points and IMO exaggerates the importance of others.

One nit to pick: Firefox 70's performance improvements didn't come from using private APIs. They used IOSurface and CALayer, both public API: https://developer.apple.com/documentation/iosurface https://developer.apple.com/documentation/quartzcore/calayer
There is a mistake somewhere: the 3270 is said to have been introduced in 1977, but to dominate the market by 1974. Could it have been introduced in 1971 instead?
Next step is that you aren’t allowed to Netflix/HBO with friends and family
I don't understand why anyone would choose MySQL over PG, honestly.
I didn't argue a regulator should be rubber stamping anything. What's with the strawman?
Nice to hear it's still around. I suppose more folks would then use burner cards with VPS providers + torrent and just sftp down their loot. I can't imagine torrenting from home is safe.
Except they didn't. Go has generic maps and slices. It was never their goal to create a language without generics. What happened is they failed to come up with a satisfactory design for user defined generics in time to make Go version 1.
Alex, you should crack open some Nietzsche. I recommend Zarathustra of course.
The "the goals at hand" are also work, even if it's not normal day-to-day work.

There is no scenario where a work event of any kind is not work.
It doesn't need one, but systemd-resolved works quite well and integrates nicely with other services. Systemd-resolved isn't mandatory, and you can still just use /etc/resolv.conf pointed to an external DNS server.
Makes me think this is a move by Google to make Android more appealing.
Insert 1984 reference here.

But also, does anyone really believe at this point that Facebook will actually delete any information (including selfies) that they have of you, ever?
This is the only way things will change. Companies need to be our in the position where holding personal data is a major liability. And not gpdr type that relies on admins or politicians. It needs to be something that excites the trial lawyers approaching the level of mesothelioma.

Idk how we get there, whether it be through the courts, Congress, or some other way. I think getting rid of third party doctrine will do more towards this goal than most people realize, but it has to be in a way that treats any data acquired by government as if it were collected by the government, to 4th amendment levels of scrutiny.

But if things are going to change, major liability on government and private sector will have to be the result, unless we want eventual relapse.
>integration between my desires and my actions

how did you decide to have these desires? if it's a good feeling, then you didn't decide that such a desire will give you this feeling; if it's based on a computed most-advantageous outcome, then you didn't decide that either. If it's a choice between the two, then who decides and how (infinite regression)?