http://java.sun.com/javaone http://java.sun.com/javaone http://java.sun.com/javaone
JavaOne - Experiencing Java technology through education, industry, and community
  2009 Platinum Cosponsor
Intel
  Cosponsors
Cosponsors
  Gen Session Cosponsors
General Session Cosponsors
  Media Sponsors
Media Cosponsors
Home > Java University

Java University

Java University is back, and better than ever in 2009! There's never been a better time to give your skill-set a boost and network with fellow developers and experts in the industry. This year's Java University has been expanded to a 2-day format, with advanced workshops that will update your skills and enhance your professional development. You will also have the option to get Java Certified, onsite. See the extensive list of courses below. Sign up now and you will be automatically entered into a drawing to win a Sun x64 Server/Developers' Platform.  
Java University
May 31 - June 1, 2009
San Francisco, CA
Java University is back, and better than ever in 2009!

Java University Program Schedule (Sunday, May 31, 2009):
Java University Program Afternoon Courses 1:30 pm - 5:00 pm
Java University Program Reception 5:00 pm - 6:00 pm
Java University Program Bonus Evening Courses 6:00 pm - 9:00 pm

Java University Program Schedule (Monday, June 1, 2009):
Java University Program Morning Courses 9:00 am - 12:30 pm
Java University Program Lunch 12:30 pm - 1:30 pm
Java University Program Afternoon Courses 1:30 pm - 5:00 pm
Java University Program Reception 5:00 pm - 6:00 pm
Java University Program Bonus Evening Courses 6:00 pm - 9:00 pm

 

Java Certification Exams

Thinking of becoming Sun Certified in Java technology? Now's your chance. Get certified while attending the JavaOne conference. Free for Java University attendees. Discounted to $79 for all other JavaOne conference attendees (regularly $300).

Dates: June 2-4
Time: 10:00 am - 6:00 pm
Room: Moscone Room 110


Choose one of the following Java University programs:


Course Descriptions (alphabetical order):

Application Performance Tuning Using Dyanmic Tracing (DTrace)

    Instructors: Phil Harman and Jon Haslam
    Course Level:
    Course Length: Bonus evening course

    Course Description:
    Solaris Operating System v10 provides a revolutionary new framework for application and system observability; Dynamic Tracing (DTrace). This course provides the students with the basic set of tools required to immediately begin using DTrace on application and systemic performance analysis. By use of examples, we will demonstrate how the student can quickly obtain views of their software stack that they never knew existed. An overview of the DTrace framework and architecture together with many examples of the D language will be presented.

    Course Approach:
    Renowned for their humorous approach to the subject, the instructors will bring lots of examples together with a modicum of interaction to demonstrate why DTrace is the answer to most of the big questions in life.

    Content:
    This session will make extensive use of live examples (typed live and not pre-canned whenever possible). We will begin with an overview of the complexity faced in behavioral analysis and why extant tools just don't make the grade. A demonstration of why DTrace is able to solve the issues faced is then presented. An overview of the DTrace architecture will then be given along with examples of how to analyze various parts of a systems software stack. This will be followed with examples of analyzing C and Java technology-based applications.

      Setting the scene: Why you need DTrace:
    • Observability and Complexity: The Way Things were
    • DTrace: The Dawn of a New Era
    • Thrill Seeking: DTrace By Example (A Quick Tour)

      DTrace: An Overview:
    • Systemic Observability By Example
      • System Calls
      • Scheduling
      • I/O and File Systems
      • Processes and Threads
      • The Kernel

      Application Analysis By Example:
    • Applying DTrace to C Based Applications
    • Adding DTrace Probes to Your Own Code (USDT)
    • Applying DTrace to Java Programming Language Based Applications

      Next Steps:
    • Resources and Pointers

    Pre-requisites:
    A general programming background is preferred but not essential.

    Objectives:
    Upon completion of this course, participants should be both motivated and able to begin applying DTrace to real life scenarios.

    Features of this course:
    • Code reviewed and demonstrated by the instructors will be available for download within a few weeks after the Java University program concludes.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by Solaris Kernel engineers.
    • Instructors will be available for Q/A immediately following the course

    Job roles this course is applicable to:
    • Developers and System Administrators

 Back to course options


Building Robust Solutions with GlassFish Enterprise Server and MySQL Database

    Instructors: Shreedhar Ganapathy and Joe Boulenouar
    Course Length: Bonus evening course

    Course Description:
    This course introduces GlassFish Enterprise Server as a platform for deploying services ranging from simple Web applications to enterprise-scale applications and Web services. The GlassFish Enterprise Server is based on the Java Platform, Enterprise Edition (Java EE) 5. Developers can deploy and manage applications based on JavaServer Pages (JSP) technology, JavaServer Faces technology, servlets, and Enterprise JavaBeans (EJB) technology. This course also covers Cluster and Enterprise profiles. Students learn to configure, administer, and deploy Web applications, EJB 3.1 applications, and Web services on an application server. The course explains how to enable the various advanced application server features, such as in-memory replication, HADB, load-balancing, monitoring and logging, clustering, and security, to the deployed applications. Integration of the MySQL database and GlassFish application server, V3 (Prelude) and value added features are also covered.

    Course Approach:
    This course will focus on the usage of GlassFish Application Server, using code examples. The demos for this course feature the Project GlassFish Enterprise Server Enterprise Profile, and the NetBeans Software IDE with the Visual Web Pack.

    Content:
    • GlassFish Application Server Installation and Registration
    • GlassFish Application Server Features
    • Configuring GlassFish Enterprise Server
    • Clustering and Load Balancing
    • Configuring and Using In-Memory Replication for Session Persistence
    • Configuring and Using HADB
    • Working with Databases
    • Advanced Configuration and Administration
    • Development Tools Support
    • Securing GlassFish Enterprise Server
    • Java Persistence API
    • Integration of MySQL database with GlassFish Application Server
    • GlassFish Application Server Value Added Features
    • GlassFish Project V3

    Pre-requisites:
    A general programming background is preferred but not essential.

    Objectives:
    Upon completion of this course, participants should be both motivated and able to use GlassFish Application Server for their development and production systems.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available for download within a few weeks after the Java University program concludes.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented GlassFish Application Server experts.
    • Instructor will be available for Q/A immediately following the course.

    Job roles this course is applicable to:
    • Developers, Administrators, and Architects

 Back to course options


Cloud Computing: Developing, Deploying and Managing Applications in the Cloud

    Instructors: Todd Fast and Chris Webster
    Course Level: Beginner to Intermediate
    Course Length: Evening Bonus Course

    Course Description:
    Students will learn how cloud computing development is the use of platforms and use of computer technology whereby dynamically scalable, virtualized resources are provided as a service over the Internet. Users need not have knowledge of, expertise in, or control over the technology infrastructure that supports them. Students will learn the types of cloud computing such as utility computing, platform as a service, and cloud-based end-user applications.

    Course Approach:
    The instructor will explain the concept of each topic, then do a demonstration emphasizing the key points, followed by a brief question and answer session.

    Content:
    • Cloud Computing Concepts
    • Platform as a Service in Cloud Computing
    • Infrastructure as a Service in Cloud Computing
    • Software as a Service in Cloud Computing
    • Virtualization in Cloud Computing
    • Data Storage in Cloud Computing

    Pre-requisites:
    Some Web application development would be useful but not required.

    Objectives:
    Upon completion of this course, attendees should be able to build reasonably sophisticated Web 2.0 applications that integrate to cloud computing. 

    Features of this course:
    • Code reviewed and demonstrated will be provided after the course.
    • Attendees will be provided with a printed copy of instructor slides.
    • Instructor will be available for Q/A personally immediately following the course.

    Job roles this course is applicable to:
    • Developers and Architects

 Back to course options


Creating and Hosting Social Applications of All Shapes and Sizes with the Zembly Application

    Instructors: Todd Fast and Chris Webster
    Course Length: Bonus evening course

    Course Description:
    This course will allow developers, by using just their browser, their creativity, and working collaboratively with others, to create and publish applications for Facebook, OpenSocial, meebo, iPhone, Google Gadgets, embeddable widgets, and other social applications.

    Course Approach:
    This course covers the Zembly application, which helps developers architect applications across multiple platforms. The Zembly environment helps developers to break up applications into reusable pieces (services and widgets).

    Content:
    • Zembly application concepts
    • Building Flickr widgets
    • Building Zillow widgets
    • Facebook Integration
    • Widget Gallery
    • Building for the iPhone

    Pre-requisites:
    Participants should have a good understanding of JavaScript, CSS, HTML.

    Objectives:
    Upon completion of this course, participants should have an understanding of how to use the Zembly framework to create useful social Web applications.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available on Zembly.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by a Sun certified Java technology instructor.
    • Instructor will be available for Q/A immediately following the course

    Job roles this course is applicable to:
    • Web application developers
    • Web designers
    • Javascript developers

 Back to course options


Designing and Implementing Secure Java Technology-Based Web Services

    Instructor: Moises Lejter
    Course Level: Intermediate to Advanced
    Course Length: Full day

    Course Description:
    This course provides the students with the information they need to design, implement, deploy, and maintain secure Web services and Web service clients using Java technology components, Java APIs (Java API for XML Processing (JAXP), Java Architecture for XML Binding (JAXB), SOAP with Attachments API for Java (SAAJ), Java API for XML Registries (JAXR), Java API for XML Web Services (JAX-WS), and the Java API for RESTful Web Services (JAX-RS)) and the Java Platform, Enterprise Edition (Java EE) platform. It also provides designers with the information they need to understand Web services as a realization of Service Oriented Architecture (SOA). Students will gain an understanding of how to secure and optimize Web services using Web services standards (such as Web Services Security (WS-Security)), through the facilities built into Project Metro.

    Course Approach:
    The instructor will demonstrate coding examples illustrating the functionality of the JAX-WS API and how to secure Java technology-based Web services. The instructor will highlight and discuss sections of code related to an implementation using JAX-WS APIs and WS-Security.

    The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.

    Morning Content:
    • Java Technologies for Web Services and Platforms
      • Describe the Java technologies for Web services development approaches
      • Describe the Web services development process
    • Java API for XML Web Services (JAX-WS)
      • Describe the functionality provided by JAX-WS API for creating Web services
      • Describe the architecture of JAX-WS API
      • Using JAXB within JAX-WS
      • Compare the two development approaches provided JAX-WS API for creating Web services and Web service clients
      • Describe the various types of Web service clients
    • Defining Web Services Through WSDL
    • Web Services Processing Using JAXP, SAAJ, and JAXR for Web Services

    Afternoon Content:
    • Securing Java Web Services Security Using Message-Layer Security
      • Describe message-layer Security mechanisms (WS-Security)
      • Describe the functionality provided in Project Metro for securing Web service Applications
      • Describe the Security Assertions Markup Language (SAML) specifications for Web services
    • Optimizing Web Services Interactions
      • Using MTOM
      • Propagating Transaction Contexts (WS-Coordination and WS-AtomicTransaction standards)
      • Introducing Message Delivery Guarantees
    • Implementing Web Services Using REST
      • Building RESTful Web services in JAX-WS
      • Building RESTful Web services using JAX-RS and Jersey

    Pre-requisites:
    A thorough knowledge of Java technology, Java Platform, Enterprise Edition (Java EE), EJB architecture framework and XML, and basic knowledge of SOAP, SAAJ, WSDL, and UDDI.

    Objectives:
    Upon completion of this course, participants should have an understanding of using the Java API for XML as the standard programming model for both Web service clients and endpoints in Java EE technology applications. Students should also have an understanding of the tools and techniques available for securing a Java technology-based Web service.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by a Sun certified Java technology instructor.
    • Instructor will be available for Q/A immediately following the course.

    Job roles this course is applicable to:
    • Java Web Service Developers

 Back to course options


Developing and Deploying Mobile Enterprise Solutions Using Sun Glassfish Mobility Platform (SGMP)

    Instructor: Hans Hrasna
    Course Length: Bonus evening course

    Course Description:
    This course will allow developers to easily build mobile enterprise solutions that can access, synchronize and update corporate/enterprise information and applications securely on any mobile device. This course will also show users how to deploy and configure SGMP.

    SGMP is built on robust scalable technologies like the Java platform, GlassFish platform, and MySQL software. SGMP provides APIs and tools to rapidly build mobile client applications for many devices. It also provides out-of-the-box adapters for a number of popular back end systems like SAP and Siebel, and provides APIs and tooling to build SGMP connectors (using JAX-RS and JCA) to easily access any enterprise back end data or application.

    Course Approach:
    This course will focus on the usage of the SGMP, using demos that feature Project GlassFish Application Server Enterprise Edition, and NetBeans IDE.

    Content:
      Sun GlassFish Mobility Platform Features and Benefits
    • Mobile Client, Gateway, Connector, EIS components
    • Flexible Architectures -- Provided vs. Managed Use Cases
    • Developing Connectors -- ECBO API vs. JAX-RS, Java CAPS, Tooling
    • Developing Mobile Client Applications - MCBO API, Tooling
    • Putting It All Together -- Install, Configure, Deploy, and Run a Sample Application
    • Looking Ahead -- What's Possible in the Next Version?

    Pre-requisites:
    A general programming background is preferred.

    Objectives:
    Upon completion of this course, participants should be both motivated and able to use the SGMP.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available for download within a few weeks after the Java University program concludes.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by an SGMP expert.
    • Instructor will be available for Q/A immediately following the course

    Job roles this course is applicable to:
    • Developes

 Back to course options


Developing Enterprise Applications with the Spring Framework

    Instructor: Chris Richardson
    Course Level: Intermediate
    Course Length: Half-day course (Sunday afternoon and Monday morning)

    Course Description:
    The Spring Framework is a widely used full-stack Java technology-based application framework. Through judicious support for dependency injection (DI), aspect-oriented programming (AOP), and portable service abstraction, Spring offers a powerful and pragmatic way to develop enterprise applications.

    Course Approach:
    This course covers a broad range of topics enabling participants to gain a clear understanding of the Spring Framework. The course discusses the principles of DI and how it helps in simplifying test-driven development (TDD). It also examines the AOP concepts and their pragmatic applications. Spring has extensive support for middle-tier functionality including persistence, remoting, management, messaging, and control flow. The course illustrates the value Spring provides in these areas. Spring 2.5, a major new release of the Framework, contains many new features, such as context namespace, which offers syntax for common configuration scenarios, and simplifies configuration by harnessing the power of Java programming language annotations. The course discusses these features and ways to leverage them. By the end of the course, participants should be ready to apply Spring in their own applications.

    Morning Content:
    • The Spring lightweight container architecture, including inversion of control
    • Agile, domain-driven design techniques with Spring
    • Effective JDBC and persistence data access
    • Declarative transaction management
    • Pragmatic AOP
    • Unit testing in isolation
    • Rapid system integration testing
    • Spring support for JSR 250 annotations

    Pre-requisites:
    Participants should have the a good understanding of the Java Platform, Standard Edition (Java SE), as well as a basic knowledge of general Java Platform, Enterprise Edition (Java EE) concepts.

    Objectives:
    Upon completion of this course, participants should have an understanding of how to use the Spring Framework to create useful business applications.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available for download after completion of the class.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by a Sun certified Java technology instructor
    • Instructor will be available for Q/A immediately following the course

    Job roles this course is applicable to:
    • Business application developers

 Back to course options


Developing Games with JavaFX Software

    Instructor: Luc Duponcheel
    Course Level: Basic to Intermediate
    Course Length: Bonus evening course

    Course Description:
    JavaFX software provides a unified development and deployment model for building rich client applications that can be deployed on different platforms. It enables unprecedented collaboration between designers and developers. A very appealing aspect of the JavaFX language is its ability to define graphical user interfaces in a declarative way.

    This course gets you started with writing games using JavaFX software. In addition to demonstrating how to use the JavaFX language and its libraries, it also shows you how to make use of best programming practices like separating model (game logic), view (user output rendering), and control (user input gesture processing).

    Course Approach:
    This session is example driven: after an introduction to the basic JavaFX features, more advanced ones are introduced by need.

    Content:
    • Setting the scene
      • The basics of scene graphs and their content

    • Language basics
      • Type inference
      • File scope language constructs
        • Constants
        • Variables
        • Functions
      • Class scope language constructs
        • Instance constants
        • Instance variables
        • Methods
      • Object Literals
      • Strings
        • String-valued expressions
        • Expressions embedded in strings
      • Sequences
        • Sequence-valued expressions
        • Comprehension syntax
        • Sequence-manipulating functionality
      • Functions
        • Function-valued expressions
      • Binding

    • Packages
      • Accessibility
        • Default, package, protected, public
        • Public-read, public-init

    • Game Model
      • Entities (Information Model) of the game
      • Services (Functional Model) of the game

    • Game Control
      • Control of the game, processes user input gestures by
        • Invoking an appropriate model method
        • Invoking an appropriate view method

    • Game View
      • Static view of the game
        • Renders the nodes of the view
      • Dynamic view of the game
        • Keeps the rendered nodes up to date by binding their coordinates to their state
      • Animated view of the game
        • Animates the rendered nodes by playing a time line that changes their state

    Pre-requisites:
    Knowledge of programming in general and object-oriented (like Java technology) and/or prototype-based (like JavaScript technology) programming in particular.

    Objectives:
    • Learn the basic JavaFX language constructs
    • Use the JavaFX standard library
    • Understand how to develop JavaFX technology-based games in a structured way by separating concerns such as the game model, the game view, and the game control

    Features of this course:
    • Student will be given:
      • An electronic copy of HTML-based lab instructions
      • A printed copy of the slides
    • Instructor will be available for Q/A immediately following the session

    Job roles this course is applicable to:
    Developers who use Java and Flash technology and are interested in knowing how to start writing games in a more declarative way using JavaFX software.

 Back to course options


Developing Java Technology-Based Applications with the Java Persistence API 2.0

    Instructors: Linda DeMichiel and Bob Kellogg
    Course Level: Intermediate
    Course Length: Half-day course (Monday afternoon)

    Course Description:
    This course provides students with knowledge of the Java Persistence API needed to develop and deploy data-driven applications with Java Platform, Enterprise Edition (Java EE platform) and Java Platform, Standard Edition (Java SE platform). The Java Persistence API enables Java SE and Java EE technology developers to model database entities as POJOs (Plain Old Java Objects). The students will gain an understanding of how to program with the Java Persistence API independent of platform as well as how the Java Persistence API integrates with Enterprise JavaBeans 3.x (EJB 3.x) technology-based component services to facilitate the development of enterprise applications.

    Course Approach:
    The instructor highlights and discusses sections of code examples illustrating the functionality and use of the Java Persistence API.

    The demos for this course feature the GlassFish application server and NetBeans integrated development environment.

    Content:
      The Java Persistence API
    • The role of the Java Persistence API in a Java technology-based application
    • Understanding the principles of object/relational mapping
    • The key concepts of persistence contexts and persistence units

      Implementing Entity Classes
    • Modeling persistent state
    • Entity identity
    • Modeling entity relationships
    • Modeling inheritance relationships

      Using the EntityManager API
    • Controlling the entity lifecycle
    • Using managed and detached entities

      Using the Java Persistence API Query Language
    • Defining static queries
    • Defining dynamic queries
    • Deciding when and how to use SQL queries

      Controlling Object/Relational Mapping
    • Understanding the defaults
    • Configuring with annotations
    • Configuring and/or overriding with XML

      Implementing with Container-Managed and Application-Managed Persistence Contexts
    • Implementing with Java Transaction API (JTA) transactions
    • Implementing with the EntityTransaction API
    • Using the bootstrapping APIs in Java SE programming environments

      Leveraging Container Services for Java Technology-Based Persistence
    • Understanding transaction propagation and persistence context propagation
    • Using extended persistence contexts to implement conversations
    • Configuring and packaging a Java technology-based persistence application

    Pre-requisites:
    Knowledge of the Java programming language; basic knowledge of relational database concepts.

    Objectives:
    Upon completion of this course, participants should have an understanding of how to use the Java Persistence API to build data-driven applications with the Java SE and Java EE platforms.

    Features of this course:
    • Selections of code reviewed and demonstrated by the instructor are available for download after completion of the course.
    • Students receive a printed copy of instructor slides.
    • The instructor is available for Q&A immediately following the class.

    Job roles this course is applicable to:
    • Application developers

 Back to course options


Developing Portable Java Platform, Enterprise Edition (Java EE Platform) Applications with the Enterprise JavaBeans 3.1 Technology-Based Component API

    Instructors: Ken Saks and Bob Kellogg
    Course Level: Intermediate
    Course Length: Half-day course (Monday morning)

    Course Description:
    This course provides students with up-to-date knowledge of the Enterprise JavaBeans (EJB) 3.1 technology-based component API needed to develop and deploy portable business applications for the Java Platform, Enterprise Edition (Java EE platform). The EJB 3.1 technology-based component model has been vastly simplified to improve productivity in writing component-based applications with the Java EE programming language. The students will gain an understanding of fundamental EJB technology-based component concepts such as session beans, message-driven beans, transactions, and security and how EJB 3.1 technology-based components make it easy to use container services to develop your applications.

    Course Approach:
    The instructor highlights and discusses sections of code examples illustrating the functionality and use of EJB 3.1 technology-based components.

    The demos for this course feature the GlassFish application server and NetBeans integrated development environment.

    Content:
      Java EE Technology-Based Component Model
    • The principles of a component-based development model
    • Understanding the roles involved in developing Java EE technology-based applications

      Developing EJB 3.1 Technology-Based Component Session Beans as Business Facades
    • The role of session beans
    • The function and operational characteristics of stateless and stateful session EJB technology-based components
    • The use of annotations and dependency injection to implement session beans and their clients

      Developing EJB 3.1 Technology-Based Component Message-Driven Beans
    • The properties and lifecycle of message-driven beans
    • Developing Java Message Service (JMS) API and non-JMS-API message-driven beans

      Understanding Common EJB Technology-Based Component Concepts
    • The role of annotations and deployment descriptors
    • The bean component environment and lookups
    • Application exceptions and system exceptions
    • Packaging and deploying to an application server

      Implementing Transactions
    • Implementing container-managed transactions (CMTs)
    • Implementing bean-managed transactions (BMTs)

      Implementing Security
    • Understanding the Java EE platform security architecture
    • Declarative authorization
    • Programmatic authorization

      Advanced Concepts
    • Implementing interceptor classes and methods
    • The EJB technology-based component timer service

    Pre-requisites:
    Knowledge of the Java programming language.

    Objectives:
    Upon completion of this course, participants should have an understanding of how to use the EJB 3.1 technology-based component API to build business applications on the Java EE platform.

    Features of this course:
    • Selections of code reviewed and demonstrated by the instructor are available for download after completion of the course.
    • Students receive a printed copy of instructor slides.
    • The instructor is available for Q&A immediately following the course.

    Job roles this course is applicable to:
    • Application developers

 Back to course options


Developing Secure, Interactive Applications Hosted on a Variety of Clients, Using JavaFX Technology

    Instructor: James L. (Jim) Weaver
    Course Level: Beginner to Intermediate
    Course Length: Half-day course (Monday morning)

    Course Description:
    The JavaFX technology-based family of products comprises a set of runtime environments, widgets, development tools, and scripting environments based on Java technology. There are currently two products in the JavaFX technology-based family: the JavaFX Script and JavaFX Mobile platforms. The JavaFX Script programming language is a highly productive scripting language that enables content developers to create rich media and content for deployment in Java application environments. The JavaFX Script programming language is a declarative, statically typed language. It has first-class functions, declarative syntax, list comprehensions, and incremental dependency-based evaluation. It can make direct calls to Java technology-based APIs that are on the platform. JavaFX Mobile technology is a complete, preintegrated software system for advanced mobile devices, enabling developers to author rich, high-impact content and network-based services. Built around open and standards-based APIs and technologies (Java technology and Linux), the JavaFX Mobile platform enables applications to be leveraged across a wide range of Java technology-enabled devices. This course starts with a brief introduction of JavaFX technology, including its motivation. The rest of the course is devoted mostly to learning the JavaFX technology-based scripting language. Upon completion of the course, participants are expected to be able to build reasonably sophisticated JavaFX applications by using the JavaFX technology-based scripting language.

    Course Approach:
    The instructor explains the concept of each topic and then does a demonstration emphasizing the key points, followed by a brief Q&A session.

    Content:
    • Introduction to JavaFX technology
    • Introduction to JavaFX Script technology
    • JavaFX Script technology-based plug-in for the NetBeans IDE
    • Data binding
    • The Java 2D API
    • JavaFX platform remote communication using Java Remote Method Invocation
    • JavaFX platform client-server communication using Java API for XML Web Services (JAX-WS)
    • JavaFX Mobile technology Mli>Future of JavaFX technology

    Pre-requisites:
    Some programming experience on the Java platform is useful but not required.

    Objectives:
    Upon completion of this course, participants should be able to build reasonably sophisticated JavaFX applications.

    Features of this course:
    • Attendees receive a printed copy of instructor slides.
    • The instructor is available for Q&A immediately following the class.

    Job roles this course is applicable to:
    • Content designers
    • Application developers

 Back to course options


Extreme Performance: Tuning Java Platform, Standard Edition (Java SE Platform) for Throughput and Latency

    Instructors: Simon Roberts and Charlie Hunt
    Course Level: Intermediate to Advanced
    Course Length: Half-day course

    Course Description:
    There is a large family of software applications with very stringent response time goals and/or service-level agreements. The response time goals of this family of applications have traditionally been challenging for Java Platform, Standard Edition (Java SE platform) technology-based applications to meet, due to garbage collection pauses. However, with advancements made to Java Virtual Machine (JVM) machines and the introduction of Sun Java Real-Time System, these stringent response time requirements can be met. This course provides students with the knowledge and skills required to tune both Java SE technology-based and Java Real-Time System applications. The students will learn the skills and methods required to monitor and tune Java SE technology-based and Java Real-Time System applications. The course begins with performance-tuning Java technology-based applications that have a need for less strict, soft real-time responsiveness and follows with performance tuning of Java technology-based applications with strict and predictable real-time low-latency responsiveness requirements. Upon completion of this course, students will understand how to performance-tune a Java technology-based application with low-latency response time requirements by using Java SE technology or Java Real-Time System and they will have learned when to use Java SE technology or Java Real-Time System for a given application.

    Course Approach:
    The instructors explain the concepts behind the art of performance-tuning Java technology-based applications for low-latency responsiveness, discuss tools to help with performance tuning, and provide demonstrations emphasizing the key points. The course also includes a brief Q&A session.

    Content:
      Challenges introduced by applications in need of low latency or garbage collection pause times
    • How the Java SE platform and Java Real-Time System address those challenges

      Overview of Java SE HotSpot JVM machine garbage collectors (GCs)
    • Intro to how generational GC works
    • Overview of SerialGC collector
    • Overview of parallel/throughput collector
    • Overview of concurrent collector
      • Basics of the concurrent collector phases
      • Advantages and challenges of concurrent collector
    • Overview of G1 (garbage first) collector (in development)
    • Choosing the right collector

      Performance-tuning Java SE platform/HotSpot JVM machine for low latency
    • Garbage collection goals
    • Sizing Java technology-based heaps and heap spaces
    • Garbage collector tuning
      • Basics of garbage collector tuning
      • Detailed concurrent collector tuning
    • Monitoring tools

      Overview of Java Real-Time System

      Performance-tuning Java Real-Time System garbage collector
    • Features of Java Real-Time System that avoid GC pauses
    • Advantages and challenges imposed with each feature
    • Tips on when and how to use these features
    • Concepts of tuning Java Real-Time System GC.

    Pre-requisites:
    Basic understanding of a JVM machine is useful but not required. Programming experience on the Java platform is also useful but not required.

    Objectives:
    Upon completion of this course, attendees should be able to performance-tune a Java technology-based application that has low-latency responsiveness requirements.

    Features of this course:
    • Attendees receive a printed copy of instructor slides.
    • Attendees receive demo materials and instructions on how to perform the demos.
    • The instructor is available for Q&A immediately after the class.

    Job roles this course is applicable to:
    • Software architects
    • Application developers
    • Application systems engineers
    • Application deployment engineers

 Back to course options


Filthy-Rich Clients

    Instructor: Bryan Basham
    Course Level: Intermediate to Advanced
    Course Length: Half-day course (afternoon)

    Course Description:
    This course is based on the material from the Java Series book Filthy Rich Clients. Graphical effects and animation in GUIs can be totally gratuitous, but when done right, they can make applications more effective and users more productive.

    Course Approach:
    Expect a lot of code and demos to show how you can apply these techniques to your applications.

    The demos for the course feature the NetBeans integrated development environment.

    Content:
      Fundamentals
    • Swing and graphics fundamentals
    • Advanced graphics rendering
    • Advanced Swing rendering
    • Performance

      Animation
    • Animation fundamentals
    • Timing framework

      Effects
    • Static effects
    • Dynamic effects

    Pre-requisites:
    Basic knowledge of the Swing API. The participants should have written at least a small Swing application.

    Objectives:
    Upon completing this course, participants should have a better understanding of Swing graphics rendering and how to take advantage of that knowledge to write better, better-looking, and faster applications. They should also understand fundamentals of how to animate rendering in Swing applications to create more-dynamic desktop applications.

    Features of this course:
    • Ample demos and sample code show how to apply this knowledge in real situations.
    • Code reviewed and demonstrated by the instructor is available for download after completion of the course.
    • Students receive a printed copy of instructor slides.
    • Material is presented by a Sun-certified Java technology instructor.
    • The instructor is available for Q&A immediately following the class.

    Job roles this course is applicable to:
    • Developers

 Back to course options


Getting Started with MySQL for Developers

    Instructor: Sarah Sproehnle
    Course Level: Beginner to Intermediate
    Course Length: Bonus evening course

    Course Description:
    This session will help developers use the features of MySQL software (version 5.0). We will look at the architecture of the MySQL management system, how to write queries efficiently, how to utilize stored procedures, triggers and views, and much more.

    Course Approach:
    The instructor will discuss and demonstrate features of the MySQL server. The focus will be on MySQL software version 5.0, which is the current GA release.

    Content:
    • Describe the MySQL client/server architecture
    • Learn the various client programs and connectors that the MySQL software provides
    • Use standard and MySQL-specific syntax to write queries
    • Create views
    • Perform bulk data import and export operations
    • Create and use stored routines
    • Define triggers
    • Use the INFORMATION_SCHEMA database to access metadata
    • Optimize queries using indexes and EXPLAIN

    Pre-requisites:
    Basic understanding of SQL and relational databases a plus.

    Objectives:
    Upon completion of this seminar, students will have a good understanding of the features of MySQL software that a developer needs.

    Features of this course:
    • Student will be provided with a printed copy of instructor slides.
    • Instructor is certified as a MySQL Instructor, Developer and DBA.
    • Instructor will be available for Q/A immediately following the course.

    Job roles this course is applicable to:
    • Developers

 Back to course options


Integrating Web 2.0 and Cloud Computing to Build Next Generation Java Applications

    Instructors: Deep Bhattacharjee and Craigh McClanahan
    Course Level: Beginner to Intermediate
    Course Length: Half-day course (Sunday afternoon)

    Course Description:
    This course covers how to develop and implement Web 2.0 technology to integrate and connect to cloud computing. The student will learn how to implement a Web 2.0 front-end application using JavaScript, Ajax, CSS, and HTML to provide a rich user experience and connect to cloud computing services transparently through secure web services using REST and JSON. Students will learn how cloud computing provides ways to control capacity or add services on the fly without investing in new infrastructure, training new personnel, or licensing new software. Software, infrastructure, and platform as service are also covered.

    Course Approach:
    The instructors will explain the concept of each topic, then do a demonstration emphasizing the key points, followed by a brief question and answer session.

    Content:
    • Building a Web 2.0 application
    • Implementing Ajax with REST, JSON Web services
    • Using secure Web services to connect to a cloud
    • Cloud computing architecture
    • Making use of SOA in cloud computing
    • Making use of a software as a service in cloud computing
    • Making use of virtualization in cloud computing
    • Making use of storage in cloud computing

    Pre-requisites:
    Some web application development would be useful, but not required.

    Objectives:
    Upon completion of this course, attendees should be able to build reasonably sophisticated Web 2.0 applications that integrate to cloud computing.

    Features of this course:
    • Code reviewed and demonstrated will be provided after the course.
    • Attendees will be provided with a printed copy of instructor slides.
    • Instructors will be available for Q/A personally immediately following the course.

    Job roles this course is applicable to:
    • Developers and Architects

 Back to course options


Java Certification Workshop: Review and Prep Session to Pass the Sun Certified Java Programmer Certification Exam

    Instructors: Evan Troyka and John Ranta
    Course Level: Intermediate
    Course Length: Half-day course (Sunday afternoon)

    Course Description:
    This course seeks to prepare attendees to successfully pass the Sun Certified Java Programmer (SCJP) 6.0 exam.

    Course Approach:
    The instructor highlights, demonstrates, and discusses concepts and source code related to certification subjects for developing in the Java programming language.

    Content:
    • Java programming environment fundamentals such as CLASSPATH, compiler and runtime CLI flags, package/directory structures, Java Archive (JAR) files, and garbage collection
    • Java programming language fundamentals such as pass-by-value versus pass-by-reference; arithmetic, logical, assignment, and comparison operators; flow control and looping; try/catch and assertions; common language exceptions and errors; variable-length arguments
    • Coding concurrent applications with java.lang.Thread and java.lang.Runnable. Object locking, Object.wait(), Object.notify(), and Object.notifyAll()
    • Object-oriented programming (OOP) and the Java programming language: encapsulation, inheritance polymorphism, overloading, overriding, this, static, super, constructors, and interfaces as well as inner and nested classes
    • API usage:
      • java.lang - wrapper classes, autoboxing and autounboxing, interface Comparable interface and class Class
      • java.util - generics and collections, sorting and natural ordering, Comparator, NavigableSet, NavigableMap, Locale, and Scanner
      • java.util.regex - basics of Pattern, Matcher, String.split() and PrintStream.printf()
      • java.text - Formatters for dates, currency, and numbers, including default locale and specified locales
      • java.io - File, FileReader, FileWriter, buffered versions of I/O classes, PrintStream, PrintWriter, and Console; serialization of objects and the various streams used; keyword transient and annotation @Transient

    Pre-requisites:
    Java technology programming experience

    Objectives:
    Upon completion of this course, students will have a better understanding of what parts of Java technology they need to understand in order to help them be prepared for the SCJP 6.0 exam.

    Features of this course:
    • Code reviewed and demonstrated by the instructor is available for download upon completion of the class.
    • Students receive a printed copy of instructor slides.
    • Material is presented by a qualified instructor
    • The instructor is available for Q&A immediately following the course.

    Job roles this course is applicable to:
    • Java technology developers

 Back to course options


Learning How to Develop Java Platform, Micro Edition (Java ME Platform) and JavaFX Mobile Applications for Mobile Devices

    Instructors: Petr Suchomel and Timothy Miller
    Course Level: Beginning to Intermediate
    Course Length: Half-day course (Monday afternoon)

    Course Description:
    With billions of Java technology devices all over the world, Java Platform, Micro Edition (Java ME platform) with the current MSA (Mobile Service Architecture) profile is one of the hottest technologies for which to build and deploy applications. And with the upcoming JavaFX Mobile deployment platform, development for mobile devices is becoming even more attractive. In this course, you will learn about these technologies, from a basic introduction to the Java ME and JavaFX Mobile platforms to how you can easily build applications by using the NetBeans IDE, to how you can add graphics and media to your application, and you will find out how to successfully test and deploy your application. Finally, you will have a chance to apply what you have learned by building your own sample application during a lab. The instructor also shows different approaches to using common Java code and libraries with front ends built on either Java ME/MSA or JavaFX Mobile technology-based profiles.

    Course Approach:
    The instructor highlights and discusses sections of code related to the development of Java ME and JavaFX Mobile technology-based mobile applications. The course shows how to use the NetBeans IDE to create, test, and deploy an application for mobile devices. The instructor also shows code samples, technical approaches, and differences involved in adding graphics and media to a Java ME or JavaFX Mobile technology-based application.

    Content:
    • Introduction to the Java ME and JavaFX Mobile platforms
    • Commonalities and differences in application development
    • How to set up and use the NetBeans IDE for Java ME and JavaFX Mobile technology-based projects
    • Using media and graphics in your applications
    • Creating interoperable code and shared libraries
    • Incorporating Web services into applications
    • Testing your application

    Pre-requisites:
    Objectives:
    Upon completion of this course, participants should have an understanding of how to create Java ME/JavaFX Mobile technology-based applications by using the NetBeans IDE and be able to incorporate media and graphics capability into their applications.

    Features of this course:
    • Code reviewed and demonstrated by the instructor is available for download upon completion of the course.
    • Students receive a printed copy of instructor slides.
    • Material is presented by a Sun-certified Java technology instructor.
    • The instructor is available for Q&A immediately following the class.

    Job roles this course is applicable to:
    • Developers of Java ME/JavaFX Mobile technology-based applications

 Back to course options


More Than Skin Deep: JavaServer Faces (JSF) 2.0 Foundation and Practice

    Instructors: Ed Burns and Chris Schalk
    Course Level: Intermediate
    Course Length: Half-day course (Sunday afternoon)

    Course Description:
    This course provides an in-depth survey of JavaServer Faces (JSF) 2.0, the standard Web Application Framework for Java Platform, Enterprise Edition (Java EE) 6. Because many of the new features in JSF 2.0 provide a clean break from previous versions of the framework, it makes sense to present the course from a perspective that does not assume prior experience with the framework. Naturally, experienced JSF users will also benefit from this course because migration strategies will be presented as sidebars in context. Typical JSF gotchas will also be covered in context.

    Course Approach:
    Because JSF technology unifies several other layers of the Java EE stack, the course will approach JSF technology from three distinct, but related, viewpoints: the application developer, the UI Component developer, and the framework extender.

    The demos for this course feature the NetBeans integrated development environment (IDE).

    Content:
    • Introducing JSF technology: High level subsystems block diagrams
    • Application developer viewpoint
      • Sample application traversal
      • Database layer, including JSR 299, WebBeans
      • Model layer, Managed Beans, JSR 303, BeanValidation
      • View and Controller Layer, including Ajax
    • UI Component developer viewpoint
      • Composite Components, including JSR 276 metadata
      • Resource Libraries
      • Ajax integration
      • Scripting to save time
      • Component annotations
    • Framework extender viewpoint
      • Patterns that enable extension
      • Survey of extension points
      • Sample extensions

    Pre-requisites:
    Java technology programming and Web framework experience.

    Objectives:
    Upon completion of this course, participants should be able to quickly and repeatably create practical and effective Web applications using JSF.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by Ed Burns, author and co-specification lead for JSR 127, JSF.
    • Instructors will be available for Q/A immediately following the course.

    Job roles this course is applicable to:
    • Java technology Web application developers

 Back to course options


NetBeans Integrated Development Environment (IDE) 6.5 Architecture and Its Powerful Plugins

    Instructor: Tim Boudreau
    Course Length: Bonus evening course

    Course Description:
    The NetBeans Integrated Development Environment (IDE) provides a powerful set of easy-to-use tools for all types of Java technology development: Java Platform, Standard Edition (Java SE), Java Platform, Enterprise Edition (Java EE), and Java Platform, Micro Edition (Java ME). Beyond Java technology development, the NetBeans IDE has tools for doing development in C/C++, Ruby, and for building SOA applications. With the release of NetBeans IDE 6.5, even more developers have switched over (or come back) to using the NetBeans IDE. This course will show you just some of the reasons to make the switch.

    Course Approach:
    This course will focus on the usage of the NetBeans IDE, and understanding of features and plugins, using code examples to present these powerful features.

    The demos for this course feature the Project GlassFish Application Server Enterprise Edition, NetBeans Software IDE with the Visual Web Pack, and other plugins.

    Content:
    • Introduction to NetBeans IDE
    • A powerful GUI builder for creating desktop applications
    • Comprehensive profiling tools for helping you track down performance bottlenecks and memory leaks
    • Leading-edge support for scripting languages such as Ruby and its Ruby On Rails framework

    Pre-requisites:
    A general programming background is preferred.

    Objectives:
    Upon completion of this course, participants should be both motivated and able to use the powerful NetBeans IDE.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available for download within a few weeks after the Java University program concludes.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by a NetBeans expert.
    • Instructor will be available for Q/A immediately following the course.

    Job roles this course is applicable to:
    • Developers

 Back to course options


Rapid Web Application Development with Groovy and Grails

    Instructor: Graeme Rocher
    Course Level: Intermediate
    Course Length: Half-day course (Sunday afternoon and Monday morning)

    Course Description:
    Grails leverages hugely popular frameworks such as Spring, Hibernate, and SiteMesh, simplifying them by using a dynamic platform and "convention over configuration." More importantly, however, it takes integration with Java technology and Java Platform, Enterprise Edition (Java EE platform) to a new level, by providing the same speed and elegance pioneered on other dynamic platforms such as Ruby and Python.

    This session will help you get up to speed with the features offered by the Groovy language and Grails framework and includes lab sessions that guide you through key elements of both.

    In addition, you will learn how to integrate Grails with existing Java technology-based enterprise services, databases, and Web applications and how to use a blended approach mixing static and dynamically typed code to maximize the scalability of your code base.

    Course Approach:
    This Groovy and Grails workshop was authored by Graeme Rocher, project lead and founder of Grails, and participants will each receive a copy of The Definitive Guide to Grails, 2nd Edition (Expert's Voice in Java), by Graeme Rocher and Jeff Brown.

    Content:
      The Groovy Tour
    • Groovy for Java Technology Developers: The Basics
      • Syntax similarities
      • New language constructs
      • Groovy Strings
      • Closures
    • What makes Groovy tick?
      • Groovy dynamism
      • Metaprogramming
      • Embedding Groovy

      Getting Started with Grails
    • Grails Introduction
      • Background, foundations, and motivations
      • Current project status
      • Why choose Grails for your project?
    • Grails Basics
      • The project infrastructure
      • Running Grails scripts
      • Creating a basic create, read, update, and delete (CRUD) application
    • The Grails Domain Model
      • Understanding domain models
        • Domain-driven development with Grails
        • Applying domain constraints
        • Defining domain relationships
      • Working with persistence methods
        • Saving, deleting, and updating
        • Using dynamic finders
        • Advanced querying with criteria and Hibernate Query Language (HQL)
    • The Web Layer
      • Orchestrating requests with controllers
        • Rendering responses
        • Handling data binding and validation
      • Groovy views with Groovy Server Pages (GSP)
        • Supplying the model
        • Logic, iteration, and filtering
        • Advanced site layouts with SiteMesh
      • Separating logic and content with tag libraries
        • Dynamic tag library basics
        • Logical and interactive tags
    • Grails Plug-Ins
      • Plug-in basics
        • Discovery
        • Installation
      • Popular plug-ins
        • Searchable
        • Quartz
        • Java Message Service
      • Creating plug-ins
        • Modularizing applications
        • Providing behavior
    • Java Technology Integration
      • Packaging and deployment onto Java EE technology-based containers
      • Grails and the Java Servlet environment
      • Wiring it all together with the Spring DSL

    Pre-requisites:
    A good knowledge of Web application development with programming languages such as the Java or JavaScript programming language. Basic understanding of HTML and Web technologies.

    Objectives:
    • Understand the basics of the Groovy language
    • Explore Groovy's power features
    • Learn about the background of Grails
    • Discover the possibilities with Grails' Hibernate-powered object-relational mapping (ORM) layer
    • Learn about Grails' MVC components
    • Understand how to integrate Grails with existing Java technology-based components and services


    Features of this course:
    • Students receive a printed copy of instructor slides.
    • The instructor is available for Q&A immediately following the class.

    Job roles this course is applicable to:
    • Java technology developers interested in the dynamic language landscape and looking to explore the possibilities of powerful dynamic languages

 Back to course options


Using Java EE and SOA to Help Architect and Design Robust Enterprise Applications

    Instructors: Joe Boulenouar and Frank Kieviet
    Course Level: Intermediate to Advanced
    Course Length: Full day

    Course Description:
    This course provides students with the knowledge needed to use Java Platform, Enterprise Edition 5 and 6 (Java EE 5 and 6 platforms) best practices and patterns to design and architect robust enterprise applications that allow for rapid change and growth. The students will gain an understanding of the latest Java EE 5 and 6 technology patterns and how they help solve important and recurring design problems. They will also learn how service-oriented architectures (SOAs), implemented in a wide range of technologies (including REST, RPC, RMI, DCOM, CORBA, and Web services), help businesses respond more quickly and cost-effectively to changing market conditions. The course also covers Enterprise Service Bus (ESB) — based on the Java Business Integration (JBI) specification – which helps automate, manage, and optimize business processes and workflows across systems, people, and partners and helps build robust cloud computing applications. The students will also learn best practices for preparing for Java Enterprise Architecture certification.

    Course Approach:
    This course focuses on the use of Java EE technology patterns from the architectural and design perspectives and also covers enterprise SOA and cloud computing. The instructor uses UML diagrams and code segments to present these patterns. The demos for the course feature Sun GlassFish Enterprise Server, NetBeans Visual Web Pack, Sun Java Composite Application Platform Suite for the Enterprise Designer, and Sun Java System Web Server.

    Morning Content:
      System Architecture Development and Guidelines
    • Justifying the need for architecture when developing for Java EE technology-based applications
    • Resolving risk factors in distributed enterprise systems
    • Guidelines for effective network communication
    • Guidelines for handling distributed transactions
    • Analyzing quality-of-service requirements

      Software Architecture
    • Decomposing Java EE technology-based applications into components
    • Deployment diagrams representing the architecture and design model

      Use of Java EE Technology Patterns
    • Describing Java EE technology patterns that assist in the presentation tier
    • Web 2.0 design patterns
    • Describing Java EE technology patterns that assist in the business tier
    • Describing Java EE technology patterns that assist in the integration tier

    Afternoon Content:
      Understanding Enterprise SOA
    • Using SOA for enterprise application integration
    • Describing how SOA improves B2B business processes
    • Service-oriented architecture and design

      Building Composite Applications
    • Web services design patterns
    • Integrating and orchestrating applications services
    • JBI components: service engines and binding components
    • Enterprise Service Bus: transformation, routing, and orchestration

      Building Cloud Computing Applications
    • Cloud computing architecture
    • Impact of Java EE technology on cloud computing
    • Impact of SOA on cloud computing

    Pre-requisites:
    Knowledge of the Java programming language and Enterprise JavaBeans (EJB) component technologies and an understanding of Java EE technology-based application servers and distributed systems.

    Objectives:
    Upon completion of this course, participants should understand how Java EE technology patterns can help them architect and design robust Java EE technology-based applications. They should also understand the advantages of building enterprise SOA architectures.

    Features of this course:
    • Use case diagrams illustrating a solution to a given problem are provided to the students.
    • Code reviewed and demonstrated by the instructor are available for download after completion of the course.
    • The students receive a printed copy of instructor slides.
    • Material is presented by a Sun-certified Java technology instructor.
    • The instructor is available for Q&A immediately following the class.

    Job roles this course is applicable to:
    • Java EE platform architects and designers
    • Project managers
    • Development managers

 Back to course options


Using the Power of JRuby and Rails to Develop Robust Applications

    Instructor: Sang Shin
    Course Level: Beginner to Intermediate
    Course Length: Half-day course (afternoon)

    Course Description:
    It is well known that Ruby on Rails is gaining quite a bit of popularity among developers and deployers of Web applications ... and for good reason. Ruby is a fun programming language to use, and Rails is considered a well-thought-out Web application framework based on development principles such as "Don't repeat yourself" (DRY) and "convention over configuration," which enable an agile yet practical development environment. JRuby on Rails provides another benefit, by leveraging the stability, reliability, and scalability of the Java platform. This course briefly goes through the interesting language characteristics of the Ruby programming language such as metaprogramming aspects, blocks, and closures. The rest of the course is devoted to learning the Rails framework - ActiveRecord, ActionController, ActionView, testing, REST support, Ajax, and deployment options — as time permits. This course is based on the contents of the "Ruby/JRuby/Rails Programming (with Passion!)" online course, which can be viewed at www.javapassion.com/rubyonrails/. Participants are welcome to bring their own laptops to try the demos themselves during the class.

    Course Approach:
    The instructor explains the concept of each topic and then does a demonstration emphasizing the key points, followed by a brief Q&A session.

    Content:
    • Ruby language basics: symbol, metaprogramming, blocks, closure
    • Building a simple Rails application, step by step
    • Environment, rake, generator, Rails console, migration
    • ActiveRecord, ActionController, and ActionView
    • Ajax
    • Testing
    • REST support
    • Deployment

    Pre-requisites:
    Some Web application development experience would be useful but is not required.

    Objectives:
    Upon completion of this course, participants should be able to build reasonably sophisticated Rails applications.

    Features of this course:
    • Students receive a printed copy of instructor slides.
    • The instructor is available for Q&A immediately following the class. 

    Job roles this course is applicable to:
    • Web application developers

 Back to course options


Web 2.0: Building Dynamic Web Sites with Ajax and the Dojo Toolkit

    Instructor: Neil Roberts
    Course Level: Intermediate
    Course Length: Half-day course (Monday morning)

    Course Description:
    This course provides the students with the skills necessary to build rich, interactive Web applications using Ajax, Asynchronous JavaScript and XML technologies. We'll explore the popular the Dojo toolkit, which has Ajax components, to simplify the creation of rich Web applications. The Dojo toolkit provides many UI components including list and tree pickers, tabbed panes, animated buttons, rich text editing, date and color pickers, and more.

    Course Approach:
    The instructor will highlight, demonstrate, and discuss concepts and source code related to the development of modern dynamic Web pages.

    The demos for this course feature the NetBeans integrated development environment (IDE).

    Content:
      Introduction to Dojo
    • Major components and a broad overview of capabilities
    • Getting started: Dojo configuration and setup
    • Dojo code structure
    • API documentation and Dojo Book
    • SitePen's Dojo Toolbox

      Dojo Fundamentals
    • Dojo's package system
    • Base tools (dojo.trim, etc.)
    • Project configuration

      Document Object Model (DOM) with Dojo
    • Dojo's DOM APIs
    • dojo.attr
    • dojo.place
    • dojo.style
    • dojo.html
    • dojo.query
    • dojo.behavior

      Events with Dojo
    • Using callbacks in Dojo
    • Event listeners with dojo.connect

      Intro to Ajax
    • Ajax with Dojo
    • Dojo's Ajax APIs
    • Data serialization
    • Deferred use in Dojo

      Dijit: the Dojo Widget System
    • What is a Dijit?
    • Dijit Sections
    • Layout Widgets
    • Form Widgets
    • Editor
    • Tree
    • Dojo Data

      Quick Overview of Advanced Topics
    • Unit Testing in Dojo
    • Using the Dojo Objective Harness (DOH) for unit testing
    • Testing methods
    • What's in DojoX
    • GFX
    • Charting
    • Grid

    Pre-requisites:
    Java technology programming experience.

    Objectives:
    Upon completion of this course, participants should be able to create Web applications utilizing Ajax. They will also be able to integrate the Dojo toolkit Web components into their Web pages.

    Features of this course:
    • Code reviewed and demonstrated by the instructor will be available for download upon completion of the class.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by a Sun certified Java technology instructor.
    • Instructor will be available for Q/A immediately following the course.

    Job roles this course is applicable to:
    • Java technology Web application developers

 Back to course options


Web 2.0: Leveraging Project jMaki, Google Web Toolkits, and Flex for Rapid Web Site Development

    Instructors: David Geary and Evan Troyka
    Course Level: Intermediate
    Course Length: Half-day course (Monday afternoon)

    Course Description:
    This course presents two programming frameworks to develop modern Web applications: Project jMaki, Google Web Toolkit (GWT), and Flex.

    Project jMaki is a lightweight client/server framework for creating JavaScript technology-centric Ajax applications using CSS layouts, a widget-based interaction model, and client services such as publish/subscribe events to tie widgets together, JavaScript technology action handlers, and a generic proxy to interact with external RESTful Web services. NetBeans users can utilize the jMaki plugin and the Ajax Update Center that hosts plugins.

    The Google Web Toolkit is a Java technology-based Web application framework that lets you implement Ajax-enabled Web applications without knowledge of Ajax or JavaScript technologies. We will start with GWT fundamentals and work our way up to advanced topics such as implementing custom widgets, database access, and using GWM - The GWT Windowing Manager. Using factories or creating objects using the new keyword can be simplified with dependency injection using Google Guice. Come see how you can develop rich, interactive Web applications with this exciting framework!

    Flex is a highly productive, free open source framework for building and maintaining expressive Web applications that deploy consistently on all major browsers, desktops, and operating systems.

    Course Approach:
    The instructors will highlight, demonstrate, and discuss concepts and source code related to the development of modern dynamic Web pages.

    Content:
      Introducing Project jMaki:
    • Describe the architecture of the Project jMaki framework.
    • Describe and demonstrate a Project jMaki Web application.
    • Describe and demonstrate the jMaki plugin for NetBeans.

      The Google Web Toolkit
    • GWT and API Introduction
    • Client and Server side code example
    • Integrating JavaScript technology
    • What's new and different in GWT 1.4.XX
    • Custom widgets
    • Database access
    • GWT Window Manager - GWM
    • Google Guice - Dependency Injection Framework

      Flex
    • Introduction
    • ActionScript, HTTPServices, and Data Binding
    • Drag and Drop
    • Components
    • Integrating Flex with the Java programming language

    Pre-requisites:
    Java technology programming experience. The student needs to be familiar with Ajax, JavaScript technology, and other Web development technologies like HTML and CSS.

    Objectives:
    Upon completion of this course, participants should be able to create modern dynamic Web applications utilizing Project jMaki, the GWT, and Flex.

    Features of this course:
    • Code reviewed and demonstrated by the instructors will be available for download upon completion of the class.
    • Student will be provided with a printed copy of instructor slides.
    • Material will be presented by qualified instructors.
    • Instructors will be available for Q/A immediately following the course.

    Job roles this course is applicable to:
    • Java technology Web application developers

 Back to course options


Writing Powerful Real-Time Web Applications Using Grizzly Comet

    Instructor: Jean-François Arcand
    Course Level: Intermediate
    Course Length: Half-day course (Sunday afternoon)

    Course Description:
    Emerging Ajax techniques — variously called Ajax Push, Comet, Reverse Ajax, and HTTP streaming — are bringing revolutionary changes to Web application interactivity, truly moving the Web into the Participation Age. This course provides a detailed introduction to the asynchronous Web and its application to social computing, explaining the underlying protocols and APIs, the challenges for application servers, and the high-level techniques available to application developers. Attendees will take away the information they need in order to add multiuser collaboration and notification features to their application by learning the Grizzly Comet Framework, an important piece of the GlassFish application server platform.

    Course Approach:
    The instructors highlight, demonstrate, and discuss concepts and source code related to the development of modern dynamic Web applications with Comet/Ajax Push.

    Content:
    • Introduction to Comet/Ajax Push
    • Description and demonstration of the anatomy of an Ajax Push/Comet interaction
    • Pros and cons of using an Ajax Push/Comet application
    • Which Web server supports Ajax Push/Comet and how
    • Which Ajax library supports Ajax Push/Comet and how
    • Demo 1: Simple chat using ICEFaces
    • Overview of the Bayeux Protocol
    • Demo 2: Simple chat using the Bayeux protocol
    • Overview of the Atmosphere Comet framework
    • Demo 3: Simple chat using Atmosphere
    • Introduction to Grizzly Comet Framework concepts and components
    • Discussion and demonstration of the use of prebuilt Grizzly Comet-enabled components
    • Rebuilding Twitter.com, step by step, with Grizzly Comet Framework
    • Demo 4: Twitter.com powered by Grizzly Comet Framework
    • Improving the Twitter.com demo by adding clustering/high-availability support, using the Grizzly Comet Framework Java Message Service extension
    • Demo 5: Clustered Twitter.com powered by Grizzly Comet Framework
    • Conclusion

    Pre-requisites:
    Knowledge of Java technology, Java Platform, Enterprise Edition (Java EE platform), and Ajax.

    Objectives:
    Upon completion of this course, participants should have an understanding of using the Grizzly Comet Framework as the standard programming model for writing Ajax Push/Comet applications.

    Features of this course:
    • Selections of code reviewed and demonstrated by the instructor are available for download after completion of the course.
    • Students receive a printed copy of instructor slides.
    • The instructor is available for Q&A immediately following the class.

    Job roles this course is applicable to:
    • Application developers

 Back to course options