Ever wondered if you can automate testing of your web application, but couldn't produce a satisfactory solution? If so, this is the session for you! Attend this session to understand the alternatives you have for unit and functional testing of web applications.

Testing a web application is a complex task. You must not only ensure that each unit is working as expected, but also ensure that your application works correctly on all target browsers and operating systems. The sad fact is that not all browsers behave in the expected, standards-compliant manner. Performing all tests manually is not only cumbersome, but also error-prone and expensive. This necessitates automated testing of the application inside all relevant browsers. With the increasing use of Javascript and AJAX, automated functional testing is becoming even more important.

This presentation will show strategies for testing web applications. It will cover both unit testing as well as functional testing. For unit testing, it will discuss the mock object approach. Since unit testing is necessary, but not sufficient, the presentation will discuss tools available for functional testing. It will also study a specific tool -- Selenium -- that simplifies functional testing. During this session, we will do live coding to solidify the concepts learned.

Aspect Oriented Programming (AOP) enables modularizing implementation of crosscutting concerns that abound in practice: logging, tracing, dynamic profiling, error handling, service-level agreement, policy enforcement, pooling, caching, concurrency control, security, transaction management, business rules, and so forth. Traditional implementation of these concerns requires you to fuse their implementation with the core concern of a module. With AOP, you can implement each of the concerns in a separate module called aspect. The result of such modular implementation is simplified design, improved understandability, improved quality, reduced time to market, and expedited response to system requirement changes. Come to this session and learn all about how AOP can help you simplify developing complex systems.

AspectJ (http://eclipse.org/aspectj) is the leading implementation of AOP for the Java programming language. AspectJ is a new language as well as its implementation. The output produced by the AspectJ compiler is compatible with the Java byte code specification. Further, AspectJ is well integrated with the most commonly used IDEs, which makes the Java developer more productive.

This session is targeted at the developer with no or little familiarity with AOP and AspectJ. It will introduce AOP’s concepts and the AspectJ programming language, along with many examples and live coding to solidify the concepts learned. After attending the session, you will have a clear idea about AOP's value and its practical applications.

Enterprise application development is a gold mine for applications of AOP. There are many crosscutting concerns found in a typical enterprise application, ranging from well-known security and transaction management to application- and technology-specific concerns. Using AOP leads to implementations that are easy to understand and easy to change.

This session shows how to address common problems faced by typical enterprise applications, with a focus on web applications using AOP. It will present examples of applying aspects to persistence, business, and web layer. It will show how to apply aspects synergistically with technologies such as Hibernate, JAAS, JMX and Spring. Many of the examples include reusable portions enabling them to be readily used in your own application.

This session is targeted at developers with familiarity with AOP and enterprise applications. It is recommended to attend the “Introduction to AOP with AspectJ” session or read articles and/or books that introduce AOP and AspectJ prior to attending this session.

Domain Driven Design (DDD) suggests dealing with complex software system using a domain model and preserving the model in implementation. Since domain model entities have rich behavior, so should their software implementation artifacts. A direct mapping between domain model and software artifacts create simple-to- understand, inexpensive-to-implement, and easy-to-evolve systems.

While the idea behind DDD isn't new and the value is easily understood, many implementations do not adhere to its principles. This disconnection may be due to many obstacles in implementing it. Combining Dependency Injection (DI) with a full-fledged aspect-oriented programming (AOP) system such as AspectJ help overcome many obstacles.

The traditional DI mechanism allows injecting dependencies into coarse-grained objects such as services exposed to the application level. However, it cannot do the same for fine-grained domain objects, which are not exposed in the same manner. The DI and AOP combination overcomes this limitation allowing creation a web of domain objects mirroring the model. Now domain classes can implement rich behavior by collaborating with dependent objects, instead of acting as mere data carriers. Further, domain concepts such as security, change tracking, and business rules are crosscutting in nature. AOP allows expressing these concepts directly using aspects.

In this session, we will examine the need for domain driven design, obstacles in achieving it, the basics of enabling behavior-richness for domain objects, and patterns of usages. This session will also present several examples that show the power behind the techniques. The knowledge gained through this session will enable you to readily apply domain driven design in your systems.