Oleg Zhurakousky

In this workshop Oleg will give a short overview of the Enterprise Integration Patterns (EIP) as catalogued in the highly influential book of the same name and Spring Integration (SI) framework. As one of the core developers of the Spring Integration(SI) framework, Oleg will provide a quick introduction of Spring Integration, its API and will demonstrate how SI enables the development of Message and Event based systems. Along the way, you will see how SI builds upon familiar Spring idioms such as interceptors, templates, strategy and other patterns. You will also see how SI maximizes reuse of the integration support available in the Spring Framework core for everything from remoting, JMS/AMQP, data, transactions, task execution and others flattening the learning curve considerably for those already familiar with Spring framework.

After attending this workshop, you will be able to start applying these patterns immediately within your Spring-based applications to solve many of the challenges of enterprise integration.
This session consists of 30% slide-ware and 70% live coding.

Today, application developers devote roughly 80% of their code to persisting roughly 20% of the total data flowing through the applications. That means two things:

• 80% of the data flowing through our applications is at best lost in rolling log files, at worst never collected – without ever being analyzed or accounted for.
• Application-level database programming, licensing, storage, administration, and ETL processing have maxed out IT budgets and have constrained app development teams from keeping pace with the rate of change in the business.
  The other 80% of the data is “Event Data” that can no longer be ignored if you want to stay competitive. Changes to application state are already stored as a sequence of events in application and middleware logs. In fact, since this data never held value to anyone but the developer in the past, a lot of potentially valuable information is often never collected. With Hadoop, we can: * store and query these events - Transaction tracing,
• use the event log to reconstruct the application domain at any point in time - ETL,
• use the same event log to construct new domains we haven't planned for - ELT, and
• automatically adjust our data domains to cope with retroactive changes - ???

In this talk, we will demonstrate how capturing all event data could dramatically simplify data collection and management within the enterprise.

This talk will explore the area of real-time data ingest into Hadoop and present the architectural trade-offs as well as demonstrate alternative implementations that strike the appropriate balance across the following common challenges:

• Decentralized writes (multiple data centers and collectors)
• Continuous Availability, High Reliability
• No loss of data
• Elasticity of introducing more writers
• Bursts in Speed per syslog emitter
• Continuous, real-time collection
• Flexible Write Targets (local FS, HDFS etc.)

“Cloud” is forcing a fundamental shift in enterprise application architecture towards a highly distributed, highly parallelized, horizontal scale-out services model. Traditional means of scale-out based on the RPC and JEE deployment model are showing their limitations when it comes to the “cloud”.
Over the past several years, with the emergence of simple J2SE-based frameworks, open TCP and non-blocking-I/O-based messaging/eventing middleware, and noSQL data stores, it is easier than ever to deliver simple and cost-effective solutions that enable the flexible distribution and parallelization of your business applications in the cloud. This new breed of middleware allows you to base your cloud application architecture on distributed light-weight Java-based components that use simple, open messaging and eventing for inter-process collaboration.

In this very hands-on presentation Oleg will build a case for the importance of Messaging architecture in the world of the cloud and show how the use of open technologies such as Spring Integration, NodeJS, RabbitMq etc., will allow you to quickly build reliable, highly available, scalable and portable systems with predictable and consistent throughput and latency. This session consists of 35% slide-ware and 65% live coding.