ClimbAClassic thanks

*forward

is that make sense :)

@@tansudasli the talk was good. minus the does it make sense. ofcourse I saw it from 28+ climbclassic thanks.

@@tansudasli does it

That’s the question I have when I see he separated tables

Cry in a fetal position ?

Waiting for a serious answer.

What you could do is say the transaction rollback is happening from service D -> C -> B -> A. For example if there was a failure when D sent the event to C. You could have a journal of events. D would send the event once and maybe receive a confirmation whether the event was consumed or not. If D didn't receive a confirmation, it could retry sending the event again. On service C side, let's say it received the event, it could store it in its local journal and try to consume it. If for any reason the event consumption failed, it could retry consuming failed events later or maybe a patch fix could be sent to service C after identifying the bug. Since the failed event is still present in its local journal. It would again try consuming it and maybe succeed now. After succeeding it would pass the event down to event B and so forth.

Vishal Gupta the rollback could fail too . I think this is a serious problem when it involves money transactions.

@@zpengh What if the action you take when the rollback fails also fails? What if the code that handles that failure also fails? There's no real guarantee on consistency if you accept the fact that any part of your system can fail, but having good testing and resilience of your systems combined with a good set of tools for your operations teams is a solid way of keeping on top of things. Good alerting, tracing, and logging will be essential to this, along with making sure that your systems/services are written defensively to notice malformed or inconsistent data and fail gracefully.

Can I Know what problem you have and what solutions you got in this video and worked for you

You must work at stitch fix

is that make sense

Thats what I did! Life without joins - its bliss

Yep，that is also what I am doing. Use cache instead, your life will be much easier!

Create[A][t0]

transactions have existed before computers and RDBs. you can get transactions by having data structures that are amenable to everybody converging on the same state. (ie: compensating transactions). when you are mutating existing records in a DB (which you dont have to do), you are creating a problem that requires the transactions in the first place; namely, undoing updates made to records. more abstractly: if you use a sharpie marker to draw out immutable functional data structures, you have not lost information when you add more structures (ie: extending a linked list where new nodes backpoint to old nodes). if you number new nodes with the current transaction, you can see that if you can't complete the transaction by adding the final node, then you just delete (or ignore) the new objects you were adding. if you use immutable append-only structs, "rollback" is trivial. of course if you have an actual side-effect (ie: launch the missles), then you can't roll back. but an RDB won't solve that problem either. if you want a consistent and mutable database, then you are saying that it's ok for all updates to stop once two halves of the network become isolated, and a vote on what the next state change is cannot pass.

You have to change the way you think. Leave SQL behind when you go distributed. You have to reuse the old architecture of hierarchy that was the norm before SQL (Think foxPRO, dBase). So basically key value pairs, mongoDB and friends. The "re-creating" of the join mechanism seems stupid a bit.

I wish other speakers did the same instead of just "reading from the prompter".

i kinda like he keep asking this

Is a bit condescending I say..does that make sense?

I can't believe people like this -"Ask me does it make sense" every 3 sentences. I am surprised and I cannot have sex for 6 months.

@@sn20 lol! wth?!

To gain your confidence 😁

Muhammad Kamran, if you listen to the speaker he is saying that you do this when you need to scale. It doesn't make sense if you don't need to scale. So, this isn't a problem for most companies and shouldn't be implemented at most companies.

I think Muhammad has a point here, though, because what seems silly here as that the primary recommendation is to split core tables to 'service-per-table', which is likely to end up being pretty naive for most monolithic databases. Considering bounded contexts and domains may be more effective _and_ more efficient.

dovh49 seems like there are other ways to scale without throwing out decades of database technology and research (clustering? sharding?), but maybe that's just me

Unfortunately those scaling technologies cost a lot of money and effort to run. Thankfully we have Amazon RDS that does quite a bit for us and even if it is costly, at least they provide that service that can scale up much better than an in-house database team for the most part.

Archimedes Trajano reinventing the wheel is surely going to be more costly in the long run than leasing someone else's working wheel. When you are in APPLICATION development, you should be caring about business application logic, not about conundrums of distributed systems design.

The point is that microservices should be individually scalable. If you have a shared database, thats a single point of failure and also a shared dependency. You can't scale the database without affecting all the connected services. That breaks the rules of microservices being independent. Take this example: You use STRIPE for your payments processing. You share the database with Stripe because "it makes everything easier", then STRIPE decides it needs to take their database offline to update it or scale it or even change it to another technology. That now affects YOU. That is the fundamental point of microservices - you bring all those dependencies into a single place that relates to one service and you communicate with the other services in your application by decoupled methods

When I watched some early presentations about this shit, I thought they were contriving examples to make them more approachable, but they actually seem serious about it. One database per table?!...

That's the way to make things scalable. You can't scale single database (well, when it is traditional relational database, not cassandra or so)

@@clray123 Nobody have mention one single database per table, that is insane. One database per service might have tens ot tables.

@Yahor Sinkevich For the great majority of applications scalability of this kind is not an issue at all. The pain in the ass caused by implementing caching and consistency management not to mention simple joins with distributed data without ACID properties is, on the other hand, quite certain. And what is a "service", how do you defined which data belongs to one service and which to another - when it's most likely that you will need to join it at one time or another (else you would have two different applications).