1,169 karma · joined August 15, 2014
> Fast forward almost a decade
If your system lasted a decade, that's a success, and any startup that just started would love to be in your shoes.
> management still doesn't understand the concept of "overwhelming technical debt".
That's a problem with your company, not with the suggestion in my post of adding in layers of abstraction when needed rather than ahead of time.
> every change to your database will break your client unless they are updated simultaneously every time (impossible for mobile apps)
You can just put up a UI forcing the user to update. Which is perfectly fine since you won't be making backward-incompatible changes to your database every month. Adding a new column doesn't break existing clients.
> or your client is aware of every backend change (very complex)
You can just put in a build date in your frontend and compare it against the date a breaking change was made. If it's <, refresh.
The article says "build a backend API when it has something to do, not as a pass through to your database."
It's good to see a considered response, rather than the typical knee-jerk reactions common on Internet forums including HN.
The article says, "build a backend API when it has something to do, not as a pass through to your database."
It doesn't say "never write any backend code".
> Your DB is likely to contain internal state that has no business being sent to the client.
Which is why not all tables need to be sent to the client. The post gives an example of exposing the friends table to the client but not others.
> If you do this, any business logic not captured in your backend has to be duplicated in each front end.
No, the post says to make your backend layer as thin AS POSSIBLE, not to not have a backend layer at all costs even if it means duplicating code.
> How do you make breaking DB changes if you take on this strategy of API design?
You change the frontend!
> This advice may be good for a proof of concept, a prototype, or an early version which stands a good chance of getting rewritten.
Which is why the blog post begins by saying, "Say you've started a startup today"
> I would not recommend it for anyone wishing to build a lasting architecture.
In a startup, I wouldn't recommend over-designing on day 1, because that's a good way of not delivering enough business value fast enough and so going bust.
> Take a look at your favorite famous internet company and look at their API and try to deduce if they follow this advice or not.
As the blog post says, you shouldn't cargo-cult Google or Amazon. You don't operate at their scale, you don't have as much traffic, you don't have as many teams, and so on. You should what makes sense for you given your company's maturity and where in the product lifecycle you are.
> This article doesn't use the word "permission" or "validation"
The article talks about it multiple times: using a database user account with limited privledges, exposing some tables but not others, exposing read but not write access, giving users access only to data they own.
> it's nearly impossible to parse and check an arbitrary SQL query for malicious intent
Which is why the article doesn't propose trying to parse and check queries for malicious intent.
> it now passes the responsibility of query performance to the FE engineer. Are appropriate indexes in place? Does the query make inappropriate JOINs?
No, in the proposal, we have backend engineer(s) to advise and assist frontend engineers. Having appropriate indices and JOINs doesn't mean you have a layer that doesn't add business value. And when it does add value, write it!
> schema changes now mean that you need to update your front end code. This means guaranteed hard downtime, because you can't control what JS folks are running in the browser.
I don't know if I understood you, but you can just force a refresh in the browser.
> you also need to make sure that queries aren't designed to intentionally DoS your DB.
That's a valid point I didn't think of.
> There's a lot wrong with the ideas presented here.
It's hard to take your criticism seriously when many of your reactions are a result of your own misunderstanding of the proposal.
> 1. You can't trust the front end. Backends must be written assuming that every call from the front end is malicious.
This is already taken care of in the proposal, by permitting clients to access only data they own.
> 2. There will be multiple front ends. If all your business logic is in the front end, you'll have to duplicate it into all of them. Where it will rapidly get out of synch and you'll have different behaviours on different clients.
No, because a) not every startup starts on multiple platforms b) you can always put common behavior into a piece that's reused. This can be a library linked in to multiple frontends, or a backend API. The post says your backend should be as thin AS POSSIBLE. It doesn't say you shouldn't have a backend at all costs, even if that means duplicating code.
> Forcing your UI to use the same entities as your database.
Nothing prevents you from mapping the entities to different ones for your frontend, in cases where you need that.
> The advice in the article strikes me as dangerously sensible-sounding while being mostly wrong.
I don't think you even understood the advice in the first place, as I can see from your misconceptions above.
If it were 0 vs 11, that would mean something, but 8 vs 11 is too close.
Instead of counting unicorns, we should count the number of successful exits, such as acquisitions. Or, second best, the number of companies that reached (say) series C funding.
OP here. If you have a better source, use it. Which source is the best was not the point of the article anyway. The point was that you should look for good stuff, not blindly watch the new movie or read the new book.
It's not about looking back at earlier versions that have shipped and trying to classify them, nor is it about asking someone else. Rather, when there's a disagreement as to whether we can launch what we have, with one side saying, "It's fine to launch, it's an MVP after all" and the other side saying "No it's not at MVP quality yet", take a step back and remember that both sides may mean different things by MVP, as the post says.
The jobs to be done framework too brings the customer into the room. If we're building a photo editor, and I say, "I wouldn't use a feature that makes lips red and removes pimples", then we can talk about the job the photo editor is being hired to do, like "make me look pretty on Instagram". I can put forward my bias like "I don't care about that" and someone can counter that.
Even if no entitlement is needed, you shouldn't have to pay a $99 rent to the platform owner to use certain APIs. That wouldn't be an open platform.
But I don't see how I benefit from some of Apple's moves, such as stealing 30% of developers' revenues [1] when their own apps don't have to suffer this tax, or Apple Music spamming me via push notification ads while others are forbidden from doing so. Or taking down apps that mention that they also support Android. All of these are in Apple's benefit, and against mine.
In 2008, I gave the benefit of doubt to walled gardens. In 2020, it's clear that they need government regulation to stop abusing both users and developers, which a monopolist otherwise tends to do. Walled gardens are still a good idea for people like you and me, but need to be controlled.
[1] When I've already paid through my nose for Apple's overpriced devices.
I'd also think that a job may not be worth doing at a given salary but worth doing at a lower salary. Isn't hiring just an ROI decision, which should theoretically make sense at a lower salary?
I like that it describes them in terms of goals ("If you prioritise X over Y, then use..."), not mechanics like stream-oriented.
I wish more technology choices were presented in terms of the fundamental tradeoffs in high-level goals rather than mechanics of the particular abstraction.