We deliver our courses in English anywhere in the world. We also sell out slide-ware. If you are interested, please contact us for a price quote.

Our courses

Advanced Java training
Test Driven Development with Java training
Continuous Integration in Java training
Java Debugging training
Advanced Swing training
AOP with AspectJ training
Building with Maven2 training
Java Design Patterns training
Java Programming training


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.


2 years experience in Java Programming.


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


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.


Familiarity with the Java language.


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


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.


Familiarity with the Java language.


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 day

Java Debugging - Syllabus


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.


Familiarity with the Java language.


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


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.


Familiarity with the Swing and the Java language.


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


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.


Familiarity with the Java language.


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


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.


Familiarity with the Java language.


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


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.


Familiarity with the Java language.


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


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.


Familiarity with Object Oriented concepts.


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

Please contact us for more information