Training

Advanced Java training - Syllabus

Abstract

Although Java is considered a relatively easy to use language, it has many sophisticated
mechanisms and delicate points that are in many cases not fully utilized or even known
to developers. A proper use of these mechanisms and "under the hood" structures
greatly enhances code optimization and fine tuning.
This ultimate course focuses on these fine points and internal mechanisms and provides
the “behind the scene” understanding of core Java libraries and the JVM internals. The
knowledge gained in the course will significantly improve developers' ability to write
more efficient and robust code.
The course includes many examples and hands-on exercises through which the material
is demonstrated and practiced. The course is based on Java6 and provides a peek at
Java7's new features.

Target Audience

JavaSE/EE developers, team leaders and Architects.

Prerequisites

2 years experience in Java Programming.

Content:

Multi Threading and the JMM (4 hours):

Introduction.
The Java Memory Model.
Core Java threading functionality.
Advanced Synchronization Mechanisms (java.util.concurrent).
Best Practices in concurrent programming.
A peek at Java7 fork/join library.

Garbage Collection (4 hours):

Introduction.
The GC Anatomy and Algorithms.
Monitoring the GC.
Reference Objects.
HotSpot Command line flags.
A peek at Java7 G1 algorithm.

Java Collections (4 hours)

The core Data Structures (List, Set, Map).
Understanding generics in and out.
The util-concurrect Copy-on-Write collections.
Queues, Dequeues and their Blocking versions.
Overview of the Apache commons-collections framework.

Java IO/NIO (4 hours)

Advanced Serialization concepts.
Buffers.
Channels.
Non blocking IO.
NIO design patterns.
Overview of Apache Mina and Grizzly.
A peek at Java7 NIO2.

Performance & Monitoring (8 hours):

The JIT compiler and the HotSpot JVM.
String Handling.
Exceptions.
JDBC Tracing.
Avoiding synchronization using Atomic Classes.
Performance Pitfalls.
Profiling using the built-in VisualVM.
Heap walking using JHat.
Monitoring using JConsole.
Agents and the Attach API.

Duration: 3 days

Test Driven Development with Java - Syllabus

Abstract

By now Test Driven Development (TDD) is a well known and appreciated practice
exercised by many development teams around the globe. Unlike the name suggests,
TDD is not a testing technique but a development technique that results in cleaner high
quality code. Implementing effective and useful TDD is a complicated task that requires
developers to have both discipline and familiarity with a set of test automation tools.
This course explains the TDD methodology, introduces a recommended set of opensource
testing tools and includes hands-on exercises (about 50% of the course's
duration) to practice the tools.

Target Audience

Java developers, team leaders and project managers.

Prerequisites

Familiarity with the Java language.

Content:

Introduction to Test Driven Development (4 hours):

Traditional software testing.
Functional/Regression/Integration/Unit Testing.
Introduction to Agile software development.
The Test First approach.
Test First challenges.
Automated Testing.
Demo.

JUnit (4 hours):

Introduction.
TestCase.
TestSuite.
Test's life cycle.
Running JUnit from the IDE.

Mock Objects & EasyMock (3 hours):

Mediator objects and Testing.
Introduction to Mock objects.
Introduction EasyMock.
Setting Mock Expectations.
Mock Verification.

Writing efficient tests and testable classes (3 hours):

What should be tested?
How to write a test - Best Practices.

Design for Testability (2 hours):

Should testing change my design?
What is design for testability.
Tips.
Dependency Injection frameworks.

Integration Testing (3 hours):

Challenges.
In Container Testing.
HttpUnit.
DBUnit.
Cactus.
Integrating Test Driven Development in the build process (1 hour):
Introduction to Ant.
Using JUnit from Ant.

Duration: 2 days.

Continuous Integration in Java - Syllabus

Abstract

Continuous Integration (CI) is an important part of any Agile methodology because it
can help the developers discover their bugs sooner. Every project can benefit from
Continuous Integration in greater productivity, early bug detection and better teamwork
due to the immediate discovering of integration bugs.
CruiseControl is a popular CI framework. It enables you to create an automated build
system. CruiseControl is an open-source, easy to use and mature solution. It contains a
lot of built-in plugins that provides you with Source Control Management integration,
mail notifications, unit-tests and many more useful features.

Target Audience

Java developers, team leaders and project managers.

Prerequisites

Familiarity with the Java language.

Content:

Introduction to Continuous Integration (2 hours):

Motivation for Continuous Integration.
Continuous Integration as part of Agile.

CruiseControl (4 hours):

Introduction.
Build Loop.
Plugins (Ant, SCM, Testing, Reporting, Mail).
Best practices for build management.

Code Analysis & Metrics (2 hours):

Introduction.
The Checkstyle framework.
Checkstyle as part of Continuous Integration.

Duration: 1 days

Java Debugging - Syllabus

Abstract

Debugging is one of the most painful and time consuming activities performed by
programmers during the development cycle. In spite of the fact that debugging is a
fundamental and repetitive activity, it is not trivial and in many cases programmers lack
the knowledge needed to apply effective and efficient debugging techniques. Acquiring
such knowledge and mastering the right tools may significantly increase productivity and
greatly reduce the time and effort needed during the debugging process.
The Eclipse integrated development environment is a great tool for debugging Java
programs. This course goes through the different tools available in eclipse, and teaches
how to use them for effective debugging.

Target Audience

Java developers and team leaders.

Prerequisites

Familiarity with the Java language.

Content:

Introduction to Java Debugging (1 hour):

Overview of the Java execution model.
Java bytecode and debug information.
Primitive debugging tools.
Java Platform Debugging Architecture (JPDA).
Debugging using static code analysis.

Introduction to Eclipse (2 hours):

Perspectives Views and Editors.
The Debug perspective.
Variables, Breakpoints and Expressions Views.

Eclipse Debugging Tools (4 hours):

Debug configuration.
Display, Register and Memory Views.
Changing variable values.
Hot code replacement.

Debugging in a Multi Threaded environment (2.5 hours):

Java threading model.
Deadlocks.
Race conditions.
Starvation.
Thread debuggers.

Debugging Memory problems (2.5 hours):

Java Memory model.
Memory related Exceptions.
Memory leaks in Java.

Debugging in complex execution environments (3 hours):

Debugging Java EE applications.
Debugging third party modules.
Remote debugging.

Best Practices (1 hour):

Server side best practices.
Client side best practices.

Duration: 2 days

Advanced Swing training - Syllabus

Abstract

Swing is a very powerful GUI framework. You can practically implement any desired GUI
using Swing. Although simple tasks are easy to implement using Swing, it is very hard to
implement sophisticated high-performance UI. The Achilles heel of Swing is its
complexity. This course will cover the design principles behind Swing and the “under the
hood” stuff the will make you “dance” Swing. As a Swing dancer, you will find Swing a
very powerful tool.

Target Audience

Swing Developers.

Prerequisites

Familiarity with the Swing and the Java language.

Content:

Swing Recap (1 hours):

History.
The Swing Composite pattern.
Lightweight vs. Heavyweight components.
Layout Managers.

The Swing MVC (4 hours):

Introduction to Model View Controller (MVC).
The Swing MVC.
Understanding Swing Model.
Decorating the Model.
The Swing View.
Introduction to pluggable look & feel

Swing and Multi-Threading (3 hours)

What’s the problem?
The Swing Threading Model.
The Event Dispatcher Thread and Event Queue.
Swing Workers.
Overview of Foxtrot.

Understanding Swing Components (5 hours):

Overview of the Swing Components.
Location, Size and Layout Managers.
Component Painting Model.
Writing your own components.
Renderers.
Editors.

Text Components (2 hours):

Text Components Hierarchy.
Documents - The text model.
Text components and multi-threading.

Images and Java2D (2 hours)

Working with Images.
Image Loading.
Volatile Images and Graphics Accelerator.
Icons.
Painting with Graphics2D.

Internationalization and Localization (2 hours)

Character Encodings.
Resource Bundles.
Native to ASCII.
BiDi.
i18n and LayoutManagers.

Pluggable Look & Feel (2 hours):

What is plaf.
The UIManager.
Working with UIDefaults.
The UI Delegates.
Implementing your own L&F.

Swing Performance (3 hours):

Common Misconceptions.
Pitfalls.
Best Practices.
Tuning.

Duration: 3 days

AOP in Java with AspectJ - Syllabus

Abstract

Aspect Oriented Programming (AOP) is a programming approach that provides the ability
to achieve modularization for crosscutting concerns, i.e., logic that applies to many parts
of the application, in a single place and to have that logic applied across the application
automatically.
By using AOP, the developer can create highly maintainable and extensible modules and
produce a code that is more readable and reusable.
AspectJ is the most popular AOP language/platform for Java and provides a powerful
compile-time and load-time solution for building AOP-based logic and adding it to an
application.
The course includes many examples and hands-on exercises by means of which the
material is demonstrated and practiced.

Target Audience

Java developers, team leaders and project managers.

Prerequisites

Familiarity with the Java language.

Content:

Introduction to AOP (4 hour):

When Object-Oriented Comes Short.
Introducing Aspects.
Advice, Joinpoints & Pointcuts.
Types of Weaving.

Using AspectJ (8 hours):

Pointcuts in AspectJ.
Load-time Weaving.
Inter-Types.
Instantiation Models.

AOP in Practice (4 hour)

AOP at Development Time.
AOP for Production.
AOP at Design Level.
Pitfalls and Best Practices.

Duration: 2 days

Building with Maven2 and eclipse - Syllabus

Abstract

Maven is a project management tool. Maven manages the build process, SCM, testing,
reporting, distribution and documentation of your projects.
Maven brings best practices and design patterns into your project management ecosystem.
The course includes many examples and hands-on exercises by means of which the
material is demonstrated and practiced.

Target Audience

Java developers, team leaders and project managers.

Prerequisites

Familiarity with the Java language.

Content:

Introduction to Maven (3 hours):

Why Another Build Framework?
Maven Principles.
Maven Architecture.
Installation & Configuration.

Maven Core (7 hours):

POM Explained.
Repositories.
Project Structure.
Managing Dependencies.
Using Profiles.
Creating Sites.
JEE and Maven.

Maven in Real World Projects (6 hours):

Writing Custom Plugins.
Testing with Maven.
Project Health with Maven.
Maven and Team Collaboration.
Packaging.
Migration to Maven.

Duration: 2 days.

Java Design Patterns - Syllabus

Abstract

Design patterns are a must for every developer. Design patterns help the developers
write extensible and maintainable code.
Design patterns also provide the developers with common vocabulary for design and
allow easy classification of conceptual problems.
The course will focus on the well known GoF patterns and their appliance in the Java
language.

Target Audience

Java developers.

Prerequisites

Familiarity with the Java language.

Content:

UML Recap (1 hour):

Class Diagrams.
Sequence Diagrams.
Interaction Diagrams.

Design Principles (2 hours):

Open/Closed Principle.
The Liskov Substitution Principle.
Design by Contract.
Inversion of Control & Dependency Injection.
Composition over Inheritance.

Creational Patterns (6 hours)

Factory.
Abstract Factory.
Builder.
Prototype.
Singleton.

Structural Patterns (6 hours)

Adapter.
Bridge.
Composite.
Decorator.
Façade.
Flyweight.
Proxy.

Behavioral Patterns (8 hours).

Command.
Mediator.
Chain of Responsibility.
Iterator.
Memento.
Observer.
State.
Strategy.
Template Method.
Interpreter.
Visitor.

Overview of non GoF Patterns (1 hour)

Duration: 3 days.

Java Programming - Syllabus

Abstract

Java is one of the most popular programming languages.
It is an Object Oriented, portable, fast and rich language. Java provides many
services out of the box (e.g. memory management, security) which help developers
be more productive.
The course is intended for anyone who wants to enter the ‘Java World’.
The course includes many examples and hands-on exercises through which the
material is demonstrated and practiced.
The course is based on Java 6.

Target Audience

Developers that want to learn the Java language.

Prerequisites

Familiarity with Object Oriented concepts.

Content:

Introduction to Java (1 hour):

The History of Java.
Java’s Key Features.
The Java Virtual Machine.
The First Application.

Basic Syntax (1 hour):

Identifiers.
Comments.
Keywords.
The Eight Primitives.
Using Objects.

Expressions (2 hours):

Using Operators.
The ‘If-Else’ Statements.
Using ‘While’ Loop.
Selecting with ‘Switch’ statement.
Dealing with Primitive Casts.

Using Arrays (1 hour):

Creating an Array.
Array Initialization.
Working with Arrays.
Using Multi-dimensional Arrays.

Java Classes – part 1 (3 hours):

Classes & Packages.
The ‘import’ Statement.
The Importance of Encapsulation.
Java Constructors.
Access Modifiers (private, default and public).
Method Overloading.

Java Classes – part 2 (4 hours):

Polymorphism and Inheritance.
The ‘Protected’ Modifier.
Using ‘this’ and ‘super’.
The ‘final’ keyword.
Static Members & Methods.

Java Classes – part 3 (4 hours):

Interfaces & Abstract Classes.
The Complete Construction Process.
The Class ‘Object’.
Nested Classes.
Enums in Java.

Basic Design Patterns (2 hours):

Basic Concepts of Design Patterns.
The Singleton Design Pattern.
The Factory Design Pattern.

Exceptions & Assertions (3 hours):

Types of Program Errors.
The Exception Model.
Checked and Unchecked Exceptions.
Defining Custom Exceptions.
Assertions.

Classpath & JARs (1 hour):

The ‘Classpath’ in Java.
Java Archives.
Working with Common Classes (2 hours):
java.lang.String
java.lang.System
java.util.Calendar
The Java Collection Framework & Generics(5 hours):
List Basics.
Using Lists Wisely.
Other Collection Classes.
Maps.
Generics.

Java IO (3 hours):

InputStream/OutputStream.
The Decorator Pattern.
Java Serialization.
Readers & Writers.
Working with Files.

Multi-Threading (5 hours):

Introducing Concurrent Programming.
Creating Java Threads.
Concurrency Problems and Synchronization.
Wait and Notify.
Concurrent Data Structures.

Networking (3 hours):

Overview.
TCP/IP Sockets.
Writing Your Own Web Server.

Duration: 5 days.