Richards, Mark, NFJS Magazine, October 2012 "Cargo Cult Programming"
http://www.nofluffjuststuff.com/m/magazine/index.jsp
PDF Download
Cargo Cult Programming is a term used to describe the process of developing software without really understanding the languages, tools, techniques, and frameworks used to develop it. Unfortunately, this Anti-Pattern still continues to plague our industry today, even though the term was coined decades ago. In this article I will describe what the Cargo Cult Programming Anti-Pattern is, why it is so bad, and some simple techniques you can use to help avoid this Anti-Pattern.

Richards, Mark, NFJS Magazine, July 2012 "Leveraging The Roles and Responsibilities Model"
http://www.nofluffjuststuff.com/m/magazine/index.jsp
PDF Download
Whether starting out from scratch or maintaining an existing application, there will always come a time when you need to add new business functionality and capabilities to an application. Which classes and components should contain the new functionality? This question may sound simple and obvious but in most cases it isn't. All too often applications end up becoming overly complex and unmaintainable due to one missing component: the simple but powerful roles and responsibility model. This article shows how the roles and responsibility model can be leveraged to build robust and maintainable software applications.

Richards, Mark, NFJS Magazine, November 2011 "High Performance Messaging"
http://www.nofluffjuststuff.com/m/magazine/index.jsp
PDF Download
As Woody Allen once said "It is impossible to travel faster than the speed of light, and certainly not desirable, as one's hat keeps blowing off". While messages traveling through your system may never quite reach the speed of light, you could certainly make them travel fast. In this article I explore four simple techniques that will increase the speed and throughput of your messaging system through relatively minor changes in your messaging infrastructure.

Richards, Mark, NFJS Magazine, May 2011 "Understanding the Difference Between AMQP and JMS"
http://www.nofluffjuststuff.com/m/magazine/index.jsp
PDF Download
As the Advanced Message Queuing Protocol (AMQP) specification matures and robust AMQP implementations such as RabbitMQ become more popular, you cant help but wonder whether you should jump on the bandwagon and use AMQP instead of Java Message Service (JMS) as your messaging standard. Understanding the differences between AMQP and JMS is a great way of understanding what AMQP is and whether you should use it. In this article I will describe AMQP through a comparison of the AMQP specification and the ever-popular JMS specification.

Richards, Mark, NFJS Magazine, July 2010 "The Secret to Building Highly Available Systems"
http://www.nofluffjuststuff.com/m/magazine/index.jsp
PDF Download
In this article you will learn why businesses are seeking the high availability grail and what high availability really means. You will learn the various topologies that support high and continuous availability, and also learn how to accurately calculate system availability. Most importantly, though, you will learn the secret to building highly available systems.

Richards, Mark, NFJS Magazine, September 2009 "The Art of Messaging"
http://www.nofluffjuststuff.com/m/magazine/index.jsp
PDF Download
Once you learn the Java Message Service (JMS) API and understand the basic configuration settings of your messaging provider, its time to apply that knowledge towards designing efficient and robust messaging systems. This article will help steer you in the right direction and teach you how to avoid some of the more common pitfalls associated with messaging.

Richards, Mark, NFJS Magazine, March 2009 "Message Driven POJOs - Messaging Made Easy"
http://www.nofluffjuststuff.com/m/magazine/index.jsp
PDF Download
Spring provides a simple yet powerful messaging framework for receiving and sending messages. In this article I will demonstrate how to develop messaging-based applications using message-driven POJOs (MDPs) and describe some ways to use them in messaging-based applications. Given that no framework is entirely perfect, I will also discuss some of the limitations with MDPs and how to get around them

InfoQ JMS Interview: Interview and Book Excerpt: Mark Richards' Java Message Service 2nd Edition
http://www.infoq.com/articles/richards-jms2
Interview and book excerpt by Srini Penchikala from InfoQ for my Java Message Service, 2nd Edition book published in May 2009.

Richards, Mark, June 2009, IBM DeveloperWorks, "Transaction Strategies: The High Performance Strategy"
http://www.ibm.com/developerworks/java/library/j-ts6/index.html
Transactions are necessary to ensure a high degree of data integrity and consistency. But transactions are also expensive; they consume valuable resources and can slow down an application. When you have a high-speed application for which every millisecond counts, you can maintain ACID (atomicity, consistency, isolation, and durability) properties to some extent by implementing the High Performance transaction strategy.

Richards, Mark, June 2009, IBM DeveloperWorks, "Transaction Strategies: The High Concurrency Strategy"
http://www.ibm.com/developerworks/java/library/j-ts5/index.html
There may be times when you need to reduce a transaction's scope to gain throughput, improve performance, and increase concurrency in the database. How do you do this and still maintain a high level of data integrity and consistency? The answer is to use the High Concurrency transaction strategy.

Richards, Mark, May 2009, IBM DeveloperWorks, "Transaction Strategies: The Client Orchestration Strategy"
http://www.ibm.com/developerworks/java/library/j-ts4/index.html
Sometimes an application's presentation layer must handle the coordination of multiple API layer method calls to complete a single transactional unit of work. In this article, I describe the Client Orchestration transaction strategy and explains how to implement it in the Java platform.

Richards, Mark, April 2009, IBM DeveloperWorks, "Transaction Strategies: The API Layer Strategy"
http://www.ibm.com/developerworks/java/library/j-ts3/index.html
An effective and robust transaction strategy is critical for maintaining data consistency and integrity. The API Layer transaction strategy is easy to implement and is well-suited for most business applications. Using examples from the Enterprise JavaBeans (EJB) 3.0 specification, I explain what this transaction strategy is and how to implement it in the Java platform.

Richards, Mark, March 2009, IBM DeveloperWorks, "Models and Strategies Overview"
http://www.ibm.com/developerworks/java/library/j-ts2.html
It's a common mistake to confuse transaction models with transaction strategies. This second article in the Transaction strategies series outlines the three transaction models supported by the Java platform and introduces four primary transaction strategies that use those models. Using examples from the Spring Framework and the Enterprise JavaBeans (EJB) 3.0 specification, I explain how the transaction models work and how they can form the basis for developing transaction strategies ranging from basic transaction processing to high-speed transaction-processing systems.

Richards, Mark, February 2009, IBM DeveloperWorks, "Understanding Transaction Pitfalls"
http://www.ibm.com/developerworks/java/library/j-ts1.html
Transaction processing should achieve a high degree of data integrity and consistency. This article, the first in a series on developing an effective transaction strategy for the Java platform, introduces common transaction pitfalls that can prevent you from reaching this goal. Using code examples from the Spring Framework and the Enterprise JavaBeans (EJB) 3.0 specification, I explain these all-too-common mistakes.

Richards, Mark, October 2008, SOA World, "Creating an Effective SOA Service Taxonomy"
http://soa.sys-con.com/node/738704
PDF Version of Article
Despite the increased knowledge and awareness of SOA, many SOA-based initiatives still struggle to get off the ground or even fail altogether. One of the many reasons for this is a lack of proper understanding and definition of what is meant by a "service" in the context of SOA. The challenge within SOA is that there are in fact many types of services. Developing a clear and effective SOA service taxonomy is crucial for any SOA initiative. This article will discuss the basic types of services used within SOA and how to build an effective service taxonomy.

Howell, S.B., Richards, W.M., Barden, S.C., Bopp, B.W., 1986, PASP, 98, p.777, "EZ Pegasi: The Last Pieces of the Puzzle"
http://adsabs.harvard.edu/abs/1986PASP...98..777H
Publication based on the research paper "On the Nature of the RS Canum Venaticorum Binary -- EZ Pegasi", Howell, S.B., Richards, W.M., Barden, S.C., Bopp, B.W., Originally published under incorrect name W.M. Williams, later corrected to W.M. Richards, published in the Publications of the Astronomical Society of the Pacific (PASP ISSN 0004-6280) Volume 98 and archived in the NASA Astrophysical Data System. This publication provides conclusive evidence of the orbital and photometric period of the cataclysmic variable star EZ Pegasi through photometric observations taken while working at Braeside Observatory through NSF Grant AST 81-15098.

Videocast: iBatis vs. Hibernate
In this videocast recorded in early 2007 I briefly discuss the major differences between iBatis and Hibernate and what the implications are of using each as your Java persistance framework

Videocast: Java EE Command Pattern Architecture
This videocast is a recording (with slides) of my 2006 NFJS conference session on Command Pattern Architecture.

The Role of the Enterprise Service Bus
In this 2005 NFJS Conference videocast (with slides) I go over what an ESB is, its role, what capabilities it provides, and the various ways an ESB can be implemented. I take a close look at the JBI specification (JSR-208) and explain what impact it will have with the ESB world. This session will teach you how to determine your own specific requirements for an ESB and then match these requirements to the product space.

Videocast: How Do You deal With SOA?
In this 2006 videocast Neal Ford and I talk about some of the issues surrounding SOA.

The Enterprise Service Bus: Do We Really Need It?
In this podcast I discuss a few of the topics I will be covering in my ESB Session at the 2007 TSS Java Symposium and NFJS Software Symposium Sessions

FDD and Agile Architecture
2005 Interview with Bob Payne from the Agile Toolkit on Feature Driven Development and Agile Architecture.