follow JDD_Krakow at
  • polski
  • english

Mark Richards

About the speaker: Is a Director and Senior Technical Architect and Collaborative Consulting, a Boston-based architecture and business consulting firm located in the U.S. Mark is the author of the recently published book “Java Message Service 2nd Edition” by O’Reilly (2009), and also the author of “Java Transaction Design Strategies” by C4Media (2006). He has published numerous articles on transaction management, service-oriented architecture, and messaging, and has contributed to numerous other books, including the recently published book “97 Things Every Software Architect Should Know” by O’Reilly and “NFJS Anthology” Volumes 1 and 2 from the Pragmatic Bookshelf. He has been involved in the architecture, design, and implementation of solutions in a variety of platforms since 1984, and is actively involved as a hand-on architect and technical leader on both large and small service-oriented architecture and systems integration efforts.


Topic: The Art of Messaging

Language: English

Abstract: The Java Message Service (JMS) API is simple, robust, and fairly easy to learn. You can quickly learn the JMS API classes and methods, and even find some decent sample code to show how they work. However, applying the JMS API to solve problems is where the art of messaging comes in. Questions such as “How many queues should I have?”, “How many listener threads should I use?”, “Why is my messaging application so slow?”, “Why won’t my messages ever expire?”, and “How do I handle exception cases when the message is gone from the queue?” are only a few of the many questions that you will most likely have when designing and building applications using messaging.

In this session I will be focusing on the art of messaging. Rather than boring you with lots of syntax, API calls, and simple code examples, I will instead show you some of the ways to design effective messaging applications. During this session I will discuss and illustrate the typical design and implementation traps most people fall into, and show how to avoid these traps. Using live code examples, I will also show some cool techniques such as multiple ways to handle exceptions during message processing and how reliably send large documents and images using message queues.


Topic: Common Anti-patterns and Ways to Avoid Them

Language: English

Abstract: In the book “97 Things Every
Software Architect Should Know” (O’Reilly, 2009) I wrote about the
importance of design patterns as a useful means of communication
between architects and developers. Equally important to patterns is an
understanding of AntiPatterns – things that we repeatably do that
produce negative results. AntiPatterns are used by developers,
architects, and managers every day and are one of the main factors that
prevent progress and success. In this session we will look at some of
the more common and significant software development antipatterns.
Through coding and design examples, you will see how these antipatterns
emerge, how to recognize when the antipattern is being used, and most
importantly, how to avoid them. By attending this session, you will be
part of a movement to reduce the AntiPattern catalog from hundreds of
entries to only a few.