What is Reddit's opinion of Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions?

From 3.5 billion Reddit comments

It’s a bit old but newer than Gang of Four. I’d also add Enterprise integration Patterns too: https://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683/ref=mp_s_a_1_3?adgrpid=117320807516&gclid=Cj0KCQiAj4ecBhD3ARIsAM4Q_jG3bNK54irXXzjN6IZANPhBVlqzE-9Af21PCdHFCfH8N-e9STNAm44aAnPJEALw_wcB&hvadid=49552640...

You don’t realize how wrong you are. Check out this book written by Martin fowler https://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683 check out the section on message ques. When you are building sophisticated enterprise architecture every feature can act as que that listens for actions to come in similar to a message que as described in the book. There is great great power in this architecture

I believe that namespace was intended for use in developing enterprise integration systems, i.e. messaging between applications, services, components, etc. I won't go into detail about what enterprise integration is but you can Google it or check out this book.

Enterprise Integration Patterns

Frankly, I don't see many people using the built-in messaging namespace much but I suppose you could if you wanted to. Check out the .NET API Reference if you need info, should have examples and what not.

If you mean GoF object-oriented design patterns, it’s been widely understood for at least a couple of decades that they mostly paper over language deficiencies, and ultimately call OOP into question.

Today, I think the question is probably more germane to, e.g. Enterprise Integration Patterns, which are more closely related to system architecture than application design and therefore less language-sensitive, although even some of these are subsumed by design choices made in “distributed compute engines” like Spark, Flink, Timely Dataflow, etc.

The design patterns book is really good that u/Carefree4 mentioned. Another one I really like, that our senior architects recommend to us all the time is Enterprise integration patterns by a bunch of top notch dudes including Martin Fowler who is known for writing a lot of architecture related books.

As someone else mentioned it used the patterns in https://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683

Read the book Enterprise Integration Patterns or go through the website. Spring Integration is basically an implementation of the patterns in this book. If you understand when to use the patterns, you will understand how and when to use SI.

Enterprise Integration Patterns. Most of the books content is available in a summarized version for free here.

I've also been enjoying "Cocos2d-x by Example: Beginner's Guide" to support my hobby.

Must-read books:

Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions – Gregor Hohpe, Bobby Wolf

Implementing Domain-Driven Design – Vaughn Vernon

Clean Code: A Handbook of Agile Software Craftsmanship – Robert C. Martin

Patterns of Enterprise Application Architecture – Martin Fowler

Refactoring: Improving the Design of Existing Code – Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts

Design Patterns: Elements of Reusable Object-Oriented Software – Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

​

And there are much more. I have collected a list on my blog: http://www.kamilgrzybek.com/programming-and-design-resources/

I really liked Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions ( http://www.amazon.com/Enterprise-Integration-Patterns-Designing-Deploying/dp/0321200683)

+1 on those books. Also:

• Building Microservices -> a fast introduction to Microservices, talks a lot about how to split concerns - touching a lot of DDD concepts - on a big app
• Enterprise Integration Patterns -> not all of it, but if you move to an event-based app it helps a lot
• Domain-Driven Design in PHP -> still only half the book in Leanpub, but really promising

disclaimer: i haven't done messaging, but here's some ways i would research to solve the problem

what first comes to mind is, if your DB is the bottleneck, try the aggregator pattern. i'm not sure if you lose durability though. another idea is to put a passthrough "filter" in the message pipeline that maintains an internal count; when the count passes your batch size, send a message on a separate control channel and reset the count. the consumer should be listening on the control, and when it receives the notification it gets messages from your main channel. that should protect durability. but you might even be able to just use a control bus. if there is no "Session.recieve(int count)" then you could probably just loop until empty or a high level count is reached. commit en masse to the database and commit.

one thing to keep in mind is to make sure you are attacking the right problem. are you sure the DB is your bottleneck?

BTW I highly recommend Enterprise Integration Patterns.