The traditional 3-tier architecture where middleware fronts back-ends may not scale for certain categories of web applications. A new category of middleware providing distributed coherent caching solutions on commodity hardware has evolved. This group of middleware is especially suitable for developing and deploying high-end eXtreme Transaction Processing (XTP) applications requiring ultra scalability and very low latency.
IBM’s WebSphere eXtreme Scale or simply eXtreme scale is one of the leading distributed coherent cache middleware products. The span of eXtreme Scale cache usage can range from simple local single JVM cache, to large distributed data grids holding hundreds of giga bytes of data hosted in a number of JVMs. eXtreme Scale does not need any JEE environment for operation. eXtreme Scale provides built-in high availability as well as elasticity. An elastic grid can transparently scale out without any grid restart simply by the addition of more grid hosting servers.
The “IBM WebSphere eXtreme Scale 6” book by Anthony Chaves (Packt -- http://www.packtpub.com/ibm-websphere-extreme-scale-6?utm_source=ibmdeveloperworksblog&utm_medium=bookrev&utm_content=blog, Amazon -- http://www.amazon.com/s/ref=nb_ss?url=search-alias%3Dstripbooks&field-keywords=IBM+WebSphere+eXtreme+Scale+6) provides an excellent exposition to eXtreme Scale which will surely benefit and will be enjoyed by a diverse eXtreme Scale community ranging from casual and curious technical investigators to serious eXtreme Scale users and eXtreme Scale aficionados. The book contains a number of sample Java code and configuration xml snippets. Most of the sample code revolves round a sample PaymentProcessor application. eXtreme Scale users can perhaps use relevant portions of the code and configuration file snippets or use the central idea behind them to construct their eXtreme Scale applications and configure their eXtreme Scale grid.
Chapter 1 of the book starts out with a very good introduction to caching, data grid, partitioning and scalability. The next two chapters introduce the two programming models provided by eXtreme Scale: the Java Map-centric ObjectMap and the JPA-centric Entity Manager programming models. The chapters on the programming models contain sample code snippets which are comprehensive enough to convey the fundamental principles but not too complex to hinder understandability.
Chapter 2 contains a superb and very useful introduction to the hash maps and various available locking strategies in eXtreme Scale with expository code samples. These topics are important for understanding and developing applications for eXtreme Scale.
Chapter 3 provides a lucid discussion on Entity Manager and Query APIs. From the coverage in Chapter 3 and later in connection with other topics, even an uninitiated reader should be able to get a firm footing and appreciate the simplicity of the ‘state of the art’ Entity Manager programming model. The detailed treatment of the topic of ‘Dynamic Index’ with an interesting example is illuminating.
Chapter 4 deals with database integration with eXtreme Scale cache. After a sound introduction to various levels of cache, the author nicely explains the usage and relationship between an in-memory data grid and relational database. The author stresses the important point that data grids are not substitutes for relational databases. Loaders serve as the integration conduit between eXtreme Scale cache and databases (in fact any back end). The Write-Behind technology with configurable flush points provides an extremely efficient way to interact with a relational database from eXtreme Scale cache which can be exploited by many applications. Chapter 4 contains a good discussion on the Write-Behind loader. The issue of referential integrity arising out of order of updates when dealing with multiple tables and JPAEntityLoader is discussed along with an interesting solution. The Write-Behind technology can never guarantee the preservation of update orders. I am not exactly sure what exact loader problem is solved by eXtreme Scale 7.0. This issue needs some clarification which will appear in http://www.packtpub.com/support.
The next two chapters of the book deal with the administration, configuration and deployment of eXtreme Scale in stand-alone environment using vanilla JVMs. Using the xsAdmin sample application utility of eXtreme Scale, Chapter 5 illustrates the elastic nature of eXtreme Scale grid. Chapter 5 contains a good practical discussion of eXtreme Scale grid capacity planning using the IBM recommended value of having 10 shards in each eXtreme Scale container at the maximally sized grid capacity. Chapter 6 delves into the built-in high availability aspects of eXtreme Scale. Again using xsAdmin, Chapter 6 demonstrates replica shards, shard placement and shard promotion during failover. The final part of Chapter 6 contains a good description of deployment consideration for an eXtreme Scale grid across multiple datacenters. For controlled shard placement, especially for disaster recovery purposes in multi-datacenter grids, eXtreme Scale allows adding portions of the grid (at the JVM level) into pre-defined 'zones'. Using XML configuration snippets and a sample startup script, the author nicely explains the configuration related to ‘zones’ and also how to place stand-alone eXtreme Scale grid-hosting JVMs in specified zones. The chapter concludes with a discussion on how to maintain locality of eXtreme Scale client request routing in a multi-data center eXtreme Scale grid environment using the 'preferZones' client property.
The ‘map’ and ‘reduce’ operators of functional programming languages are very important programming patterns in data grids. Chapter 7 of the book explores the concepts and usage of above two patterns with illustrative examples in distributed partitioned eXtreme Scale object grid environments. The factoring and composition techniques illustrated in Chapter 7 are good examples of developing clean uncluttered eXtreme Scale data grid code. The last section of Chapter 6 touches on a very interesting but somewhat advanced topic of creating massively parallel eXtreme Scale data grid applications: creating a list of buckets of objects belonging to the same partition followed by invoking the map-reduce eXtreme Scale agents in different threads, each agent taking a bucket of objects created in the first step. This technique is extremely useful to warm up large eXtreme Scale cache from back ends – see the pre-load sample code in Chapter 10.
eXtreme Scale’s ability to support ultra high scalability depends on uniformly partitioning data and spreading the partitions across machines. Developing scalable applications accessing partitioned data demands a paradigm shift in programming discipline. Denormalization of data, creation of application specific and non-generic data models, avoidance of complex transactional protocols like 2 phase commit are some of the basic principles of this new programming methodology. Chapter 8 of the book discusses some important aspects of the new programming discipline under the banner of ‘Data Grid Patterns’. I find this particular chapter to contain wealth of practically useful discussion, and sample code. Using a simple application data model, in a very elucidating style the author explained and presented various alternatives for data partitioning schemes some of which may look unnatural at first but should definitely be considered under specific circumstances as described here in this chapter. The chapter also provides excellent sample code to illustrate useful reference data loading technique using the ‘map-reduce’ pattern. This is required for scalability in certain data partitioning schemes to keep the related data in the same partition. The author eloquently stresses a fundamental principle behind programming in partitioned environments – ‘try to limit your transactions to a partition instead of the entire grid’. I really enjoyed working through the chapter and I am sure eXtreme Scale programmers and application architects will find this chapter to be informative, thought provoking and useful.
Chapter 9 of the book provides a decent coverage of eXtreme Scale integration with the Spring framework. Again with sufficiently detailed XML and code snippets, the author illustrates Spring-managed eXtreme Scale configuration and the injection of eXtreme Scale components in Spring framework. Though this chapter will be especially valuable for readers already familiar with Spring, others will also get a good idea about the underlying principle and simplicity of using eXtreme Scale with the Spring framework.
Chapter 10 is the last chapter of the book and illustrates the incorporation of eXtreme Scale grid into an existing application originally designed to be used with a single, relational database. The pre-load sections and sample code are valuable to eXtreme Scale programmers even if they are not migrating a database-centric application to use a data grid.
The first edition of this book has few weaknesses all of which can be addressed by providing a couple of sections including errata few at the relevant web page of Packt Publishing and perhaps more elegantly in the next edition of the book.
The book does not provide any list of appropriate reference material. A book dealing with a cutting edge technology should attempt to provide a comprehensive list of reference materials. At a minimum the following references should have been included:
· IBM eXtreme Scale Library: http://www.ibm.com/software/webservers/appserv/extremescale/library/index.html
· eXtreme Scale WIKI: http://www.ibm.com/developerworks/wikis/display/extremescale/Home
· Billy Newport’s blog: http://www.devwebsphere.com/
· Billy Newport’s YouTube podcasts on eXtreme Scale: http://www.youtube.com/ibmextremescale
The above list should also include WXS red books, JPA references, materials on partitioned programming, ultra scalability, etc. The text of the book should also point to the reference material when appropriate. For example, the term ‘core group’ is used in the book without any reference, and the term may not be familiar to a non-WebSphere user.
Some may prefer to deploy eXtreme Scale in WebSphere Application Server Network Deployment environment. The book does not provide any coverage on this topic. The book is silent about HTTP session management using eXtreme Scale, which is an important usage scenario of eXtreme Scale. The PER_CONTAINER partition placement strategy of eXtreme Scale is also not mentioned.
There are a few loose sentences in the book which can be misinterpreted and generate confusion. A list of them with suggested rephrasing and corrections is expected to appear soon at http://www.packtpub.com/support.
This is the first published non-IBM book on eXtreme Scale and programming in an eXtreme Scale environment. A lot of eXtreme Scale users like me were waiting for a long time for a high quality book like this which can be used to jumpstart the understanding of eXtreme Scale and also as a reference material while architecting and developing eXtreme Scale solutions. I would definitely recommend this book to all eXtreme Scale users.