News for hackers. Stuff that matters.
Re:Analysis of Software Architectures by skrebbel on Saturday January 09, 2016 @03:19PM (#10872710)
I violently agree, and I suspect most of HN does.

There's an associated danger though: I find that many startup hackers actively dismiss good ideas (and even entire programming languages) simply because they smell a bit of CoA.

Even the CoA crowd occasionally comes up with truly good ideas that have way more substance to them than the meaningless patterns mentioned in this article.

As an example: My personal pet peeve is the startup world's ignorance of Domain-Driven Design and CQRS (Command-Query Responsibility Segregation). If you want to make scalable backends, I really recommend you read up on CQRS, it's practical and it fits modern ideas. Most examples are in C#, but you'll survive.

For frontenders, CQRS is basically Flux on the backend, kinda sorta. It ought to be super hip right now but it isn't, and I suspect that's only because it comes from C#-o-world and has a ridiculous unpronounceable acronym.

Re:Analysis of Software Architectures by Terr_ on Saturday January 09, 2016 @07:22PM (#10873526)
At work I've been implementing some rough CQRS/DDD stuff for "the 2.0 system", and I'd summarize them as:

CQRS: Writes/commands and Reads/queries are fundamentally asymmetrical. Accept it and take advantage of it by having separate pipelines with different features.

DDD: Collaborate with the business-folk to discover their mental-model, and treat it and the code-model as similar co-evolving pieces. Focus on behavior and rules more than pigeonholes for data. Use Repositories to handle how RAM is not infinite, and Services for stuff you truly can't fit into meaningful objects.

Re:Analysis of Software Architectures by perlgeek on Saturday January 09, 2016 @04:44PM (#10873010)
> As an example: My personal pet peeve is the startup world's ignorance of Domain-Driven Design and CQRS (Command-Query Responsibility Segregation). If you want to make scalable backends, I really recommend you read up on CQRS, it's practical and it fits modern ideas. Most examples are in C#, but you'll survive.

Most starts never become successful enough to have to worry about scalability; in fact, if they do, it's almost a luxury.

I don't have experience with CQRS and event sourcing, but it does seem to come with its own share of problems, for example dealing with changes of the data model, which I suspect would happen often in young businesses.

Re:Analysis of Software Architectures by Terr_ on Saturday January 09, 2016 @07:24PM (#10873530)
It's very easy to do CQRS without Event-Sourcing. ES is really a separate kind of architecture-piece that's concerned with how you mutate your persisted data.

For example, at work I've got a CQRS system where the MySQL database looks pretty much like you'd expect from any other system. (Customers table, one row per customer, etc.) It's still CQRS because writes and reads occur through different paths, and writes can have side-effects to proactively-build readable data. For example, "Top 100 Happiest Customers" might be its own table--managed by application code--rather than view or query.

Re:Analysis of Software Architectures by perlgeek on Sunday January 10, 2016 @01:33AM (#10874474)
If you do it that way, you don't get the famed scalability; it's still limited by the scalability of the mysql backend.
Re:Analysis of Software Architectures by Terr_ on Sunday January 10, 2016 @01:57PM (#10876584)
Not sure exactly what capability you're referring to with the "famed" scalability, but my point is that CQRS in no way requires Event Sourcing, and offers its own set of benefits. (It's also a helluva lot easier to do, or un-do.)

In particular, CQRS helps you make a sane architecture for "read models", where certain features (say, a homepage showing a hard-to-calculate leaderboard) are simple queries against a data-source designed specifically for that feature. The backing data-source is kept up to date by application code as a side-effect of your "real work".

This means you can substantially reduce the runtime load on the database as well as reducing how much application-logic "leaks across" in triggers/procedures/views. Since your database is often the "bottleneck of last resort", this means better scalability.

Re:Analysis of Software Architectures by skrebbel on Sunday January 10, 2016 @11:58AM (#10875975)
The codebase is, however, very well structured to make that change later on.

You don't need to do a lot of CQRS to make future scalability a relatively simple redesign.