The Java University program is returning as part of the 2007 JavaOne conference. As the focus for the Conference is expanding this year, so will the number and focus of the Java University program offerings. These courses, are created and delivered by Sun certified instructors. These great technical training courses offer in-depth information on the hottest development topics in today's market.
The Java University program will be held on Monday, May 7, 2007. Only Conference Plus Pass and Java University Pass holders can participate in these sessions. This year we have added a General Session before the sessions start for all registered Java University attendees. Additionally we are offering Java University program attendees the option of taking one full-day course or a selection of two of our half-day courses.
Choose from one of the following Java technology full-day courses:
OR select one morning course and one afternoon course from the following half-day courses:
At the end of the day, if you are still yearning for more, Java University program attendees can stay for one of these four bonus evening courses*:
*Attendance is available until we have met capacity for any of these rooms.
Using Java EE 5 and SOA to Architect and Design Robust Enterprise Applications
Instructor Name: Joe Boulenouar and Ron Pinkerton
Course Level: Intermediate to Advanced
Course Length: Full-day course
Course Description:
This course provides the student with the knowledge needed to use Java Platform, Enterprise Edition 5 (Java EE 5) best practices and patterns to design and architect robust enterprise applications that allow for rapid change and growth. Students will gain an understanding of Java EE technology patterns and how, in practice, they have proven to be invaluable during the design and implementation of enterprise applications, solving important and recurring design problems. Students will also gain an understanding of how Service-Oriented-Architectures (SOA), 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. Students will also learn best practices on how to prepare for the Java Enterprise Architecture certification.
Course Approach:
This course will focus on the usage of Java EE platform patterns from the architectural and design perspectives. Understanding Enterprise SOA is also covered. The instructor will use UML diagrams and code segments to present these patterns.
The demos for this course feature the Project GlassFish Application Server, Sun Java System Application Server Enterprise Edition, NetBeans Software IDE with the Visual Web Pack, Sun Java Composite Application Platform Suite for the Enterprise Designer, Sun Java Studio Enterprise software, and Sun Java System Web Server.
Morning Content:
Fundamental Architectural Concepts
- Justify the need for architecture when developing for Java EE platform application
- Primary concerns of architecture
System Architecture Development and Guidelines
- Resolving risk factors in distributed enterprise systems
- Guidelines for effective network communication
- Guidelines for handling distributed transactions
Quality-of-Service Requirements
- Effects of dimensions on systemic qualities
- Analyzing quality-of-service requirements
Software Architecture
- Decomposing the Java EE platform application into components
- Deployment diagrams to represent the architecture and design model
Afternoon Content:
Using of the Java EE platform patterns
- Describing Java EE platform patterns that assist in the presentation tier
- Describing Java EE platform patterns that assist in the business tier
- Describing Java EE platform patterns that assist in the integration tier
Understanding Enterprise SOA
- Using SOA for enterprise application integration
- Describing how SOA improves B2B business processes
- Service-Oriented Architecture and Design
- Web Services design patterns
Pre-requisites:
A thorough knowledge of the Java programming language and EJB component modules, and an understanding of Java EE application servers and distributed systems.
Objectives:
Upon completion of this course, participants should understand of how the Java EE platform patterns help to architect and design robust Java EE technology 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 will be provided to the student.
- 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 EE Platform Architects and Designers
- Project Managers
- Development Managers
Back to course options
Get eBusiness Solutions: Designing and Implementing Secure Java Web Services
Instructor Name: John Ranta
Course Level: Intermediate to Advanced
Course Length: Full-day course
Course Description:
This course provides the students with the information they need to create, implement, and deploy 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 Platform, Enterprise Edition (Java EE). It also provides designers with the information they need to understand web services as a realization of Service Oriented Architecture (SOA). Students will also gain an understanding of how to secure web services using the XML and Web Services Security (XWS-security) framework, federated identity and Sun Java System SAMLv.2 Plugin tokens.
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 Web Services 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
Web Services Processing APIs
- Using Java API for XML processing (JAXP)
- Describe the Java Architecture for XML Binding (JAXB)
- Creating and Manipulating SOAP messages using the classes, interfaces and methods contained in the SAAJ API
- Describe the relationship between the SAAJ API and DOM
Web Services Description and Service Registry
- Describe the role of the Web Services Definition Language (WSDL)
- Describe the Web Services service registry
Afternoon Content:
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
- 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
Securing Java Technologies for Web Services using the Java EE Application-layer and Transport-layer
- Describe the various methods to implement Java EE platform security
- Describe the transport-layer security to secure a Java EE 5 web service application
Securing Java Web Services Security using Message-Layer Security
- Describe message-layer Security mechanisms
- Describe the functionality provided in XWS-Security for securing web service Applications
- Describe the Security Assertions Markup Language (SAML) specifications for web services
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, UDDI, Java Web Services Developer Pack ("Java WSDP") .
Objectives
Upon completion of this course, participants should have an understanding of using the Java API for XML Web Services ("JAX-WS") 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 Services Developers
Back to course options
Managing Complex Web Applications: Should I use Apache Struts Framework, JavaServer Faces Technology, or Both?
Course Instructor: Evan Troyka
Course Level: Intermediate to Advanced
Course Length: Full-day course
Course Description:
This course provides the students with the knowledge and the skills necessary to quickly build complex web applications from JavaServer Pages (JSP) and Servlet technologies using the web container and the Struts framework. It also provides the students with the skills necessary to build custom web-tier components using JavaServer Faces (JSF) component framework. Students will also gain an understanding of the usage of the Struts framework vs. JSF component framework when building complex web applications.
Course Approach:
The instructor will highlight and discuss sections of code related to the development of web components using the Struts MVC framework and JSF technology framework.
The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.
Morning Content:
Web Component history and MVC
- Historical problems with managing complexities in Web Applications
- Too many servlets - bloating/overhead
- Central controller approach - non-OO but more MVC
Need for frameworks to gain "ilities"
- Extensibility
- Manageability
- Flexibility
- Scalability
Struts Overview and Benefits
- Front Controller Pattern
- XML Configuration
Struts Implementation
- Struts Actions APIs
- Struts ActionForm Beans
- Struts HTML Tags
JSP Technologies
- Scripting Elements
- Overview
- Pros and Cons
- EL and JSP Technology Standard Actions
- JSTL & Struts Logic Tags
Afternoon Content:
JSF Component Overview and Framework Discussion
- Role of a JSF Component
- JSF Component Similarities and Differences to Struts
- Structure of A JSF component Page
- JSF XML Configuration File
- Navigation of a JSF Component Application
- Sun Java Studio Creator application development tool as a JSF Component Development Tool
JSF Input Components
- Beans
- JSF Component EL
- Dynamic Output
- Conversion and Validation of Form Data
JSF Application Sample
- Sample applications, source code, and configurations are presented
- Application localization is addressed
Struts or JSF? or Both?
- Migrating from Struts to JSF Components
- JSF and JSTL
- Struts Action with JSF Interface
Pre-requisites:
A thorough knowledge of the Java programming language and a basic understanding of Servlets, JavaServer Pages (JSP) technology, HTML and the design of Java technology-based applications.
Objectives:
Upon completion of this course, participants should have an understanding of how to create web applications that integrate the Struts MVC framework and the JavaServer Faces (JSF) technology framework.
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 qualified Java technology instructor
- Instructor will be available for Q/A immediately following the course
Job roles this course is applicable to:
Java Technology Web Components Developers
Back to course options
Web 2.0: Building Dynamic Websites with Ajax and the Dojo Toolkit
Instructor Name: Stacy David Thurston
Course Level: Intermediate
Course Length: Half-day course (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.
Content:
Introducing Ajax
- Describe Ajax and Ajax enable web application architectures
- Describe and demonstrate the anatomy of an Ajax interaction
- List the pros/cons of using an Ajax-based client
Tools and Technology
- Description and demonstrations of the technologies and tools used to create Ajax web applications
- Overview of sample labs that are to be presented by the instructor
- Discuss and demonstrate the use of pre-built Ajax-enabled components
- Demonstrate sample web applications that have been created using NetBeans software, and the Dojo Toolkit
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
Filthy Rich Clients
Instructor Name: Chet Haase and Romain Guy
Course Level: Intermediate to Advanced
Course Length: Half-day course (morning)
Course Description:
Authors Chet Haase and Romain Guy present material from their new 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 this 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 participant should have written at least a small-sized 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. Participants should also understand fundamentals of how to animate rendering in Swing applications to create more dynamic desktop applications.
Features of this course:
- A wealth of demos and sample code will show how to apply this knowledge in real situations.
- The instructors are well-versed in Swing and Java technology, from both an external developer as well as internal library implementor perspective, and will be able to field attendee questions during the course.
Back to course options
Developing Portable Java EE Applications with the Enterprise JavaBeans 3.0 Component API
Instructor Name: Ken Saks and Moises Lejter
Course Level: Intermediate
Course Length: Half-day course (morning)
Course Description:
This course provides the student with up-to-date knowledge of the EJB 3.0 component API needed to develop and deploy portable business applications for the Java EE platform. The EJB 3.0 component model has been vastly simplified to improve productivity in writing component-based applications with the Java EE platform. Students will gain an understanding of the fundamental EJB component concepts such as session beans, message-driven beans, transactions, and security, and how EJB 3.0 components make it easy to use container services to develop your applications.
Course Approach:
The instructor will highlight and discuss sections of code examples illustrating the functionality and use of EJB 3.0 components.
The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.
Content:
Java EE Platform Component Model
- The principles of a component-based development model
- Understanding the roles involved in developing Java EE platform applications
Developing EJB 3.0 Component Session Beans as Business Facades
- Describe the role of session beans
- The function and operational characteristics of stateless and stateful session EJB components
- The use of annotations and dependency injection to implement session beans and their clients
Developing EJB 3.0 Component Message Driven Beans
- The properties and life cycle of message-driven beans
- Developing Java Message Service (JMS) API and non JMS API message-driven beans
Understanding Common EJB Component Concepts
- The role of annotations and deployment descriptors
- The bean component environment and lookups
- Application Exceptions and System Exceptions
- Packaging and deployment to an application server
Implementing Transactions
- Implementing Container-Managed Transactions (CMT)
- Implementing Bean-Managed Transactions (BMT)
Implementing Security
- Understanding the Java EE platform security architecture
- Declarative authorization
- Programmatic authorization
Advanced Concepts
- Implementing Interceptor Classes and Methods
- The EJB Component Timer Service
Pre-requisites:
A thorough knowledge of the Java programming language.
Objectives
Upon completion of this course, participants should have an understanding of how to use the EJB 3.0 Component API to build business applications with the Java EE platform.
Features of this course:
- Selections of 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.
- The Instructor will be available for Q/A immediately following the course.
Job roles this course is applicable to:
Application Developers
Back to course options
Developing Enterprise Applications with the Spring Framework
Instructor Name: Keith Donald
Course Level: Intermediate
Course Length: Half-day course (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. This course teaches participants how to get the most out of Spring.
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.0, a major new release of the framework, contains many new features such as namespace support and AspectJ integration. 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.
The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.
Content:
- The Spring Lightweight Container Architecture, including Inversion of Control
- Agile, domain-driven design techniques with Spring
- Effective JDBC and Hibernate data access
- Declarative transaction management
- Pragmatic AOP
- Unit testing in isolation
- Rapid system integration testing
- Spring's Web Support (MVC, Web Flow, and Web Services)
- Spring Security, Remoting, and Java Management Extensions (JMX) API
Pre-requisites:
Participants should have the a good understanding of the core Java platform, as well as a basic knowledge of general Java Platform, Enterprise Edition (Java EE) concepts, such as JavaServer Pages (JSP) technology and Servlets.
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:
- Student will be provided with a printed copy of instructor slides
- 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
Web 2.0: Leveraging the Project jMaki and Google Web Toolkits for Rapid Website Development
Instructor Name: David Geary (Google Toolkit) and Stacy David Thurston (Project jMaki)
Course Level: Intermediate
Course Length: Half-day course (afternoon)
Course Description:
This course presents two programming frameworks to develop modern web applications: Project jMaki and Google Web Toolkit (GWT).
Project jMaki is a lightweight client/server framework for creating JavaScript technology centric Ajax applications using CSS layouts, a widget-based interaction model, 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. Project jMaki can interact with many Ajax component libraries, such as the Dojo toolkit.
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. This tutorial spans the gamut of developing applications with GWT. We will start with GWT fundamentals and work our way up to advanced topics such as implementing custom widgets, database access, and drag and drop. Come see how you can develop rich, interactive web applications with this exciting framework!
Course Approach:
The instructor 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
- Demonstrate a jProject Maki web application that uses the Dojo toolkit
The Google Toolkit:
- GWT and API Introduction
- Client and Server side code example
- Integrating JavaScript technology
- Custom widgets
- Database access
- File uploads
- Deploying to external servers
- Incorporating GWT into other applications
- Drag and Drop
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 and the GWT.
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 qualified 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
Learning How Java ME Development Works Best for Mobile Devices
Instructor Name: Timothy Miller
Course Level: Beginning to Intermediate
Course Length: Half-day course (afternoon)
Course Description:
With billions of Java technology devices all over the world, Java Platform, Micro Edition (Java ME) is still one of the hottest technologies to build and deploy applications for. In this class, you will learn about Java ME, from a basic introduction to the Java ME platform and midlets, to how you can easily build a Java ME platform application using the NetBeans Mobility Pack IDE, to how you can add graphics and media to your application, and how to successfully test and deploy your application. Finally, you will have the chance to apply what you have learned in by building your own sample application during our lab.
Course Approach:
The instructor will highlight and discuss sections of code related to the development of the Java ME platform mobile application. The instructor will show how to use NetBeans Mobility Pack to create, test and deploy an application for a mobile device. The instructor will also show code samples and technical tips on adding graphics and media to a Java ME platform application.
Content:
- Introduction to the Java ME platform and application development
- How to start your application development within the Mobile & Embedded Community
- How to use the NetBeans Mobility Pack to start building your mobile application.
- Adding graphics and media to your Java ME platform application using the NetBeans Mobility Pack
- How to incorporate Web Services in a Java ME platform application.
- Testing Best Practices for the Java ME platform application.
Pre-requisites:
Objectives
Upon completion of this course, participants should have an understanding of how to create Java ME platform applications using NetBeans Mobility Pack and be able to incorporate media and graphics capability.
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 ME Platform Application Developers
Back to course options
Developing Java Technology Applications with the Java Persistence API
Instructor Name: Linda DeMichiel and Moises Lejter
Course Level: Intermediate
Course Length: Half-day course (afternoon)
Course Description:
This course provides the student with knowledge of the Java Persistence API needed to develop and deploy data-driven applications with the Java EE and Java SE platforms. The Java Persistence API is a new persistence API that allows Java SE and Java EE technology developers to model database entities as POJOs (Plain Old Java Objects). 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 EJB 3.0 component services to facilitate the development of enterprise applications.
Course Approach:
The instructor will highlight and discuss sections of code examples illustrating the functionality and use of the Java Persistence API.
The demos for this course feature the Project GlassFish Application Server and NetBeans integrated development environment.
Content:
The Java Persistence API
- The role of the Java Persistence API in a Java technology 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 the 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 JTA transactions
- Implementing using the EntityTransaction API
- Using the bootstrapping APIs in Java SE environments
Leveraging Container Services for Java Persistence
- Understanding transaction propagation and persistence context propagation
- Using extended persistence contexts to implement conversations
- Configuring and Packaging a Java 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 will be available for download after completion of the class.
- Student will be provided with a printed copy of instructor slides.
- The Instructor will be available for Q/A immediately following the course.
Job roles this course is applicable to:
Application Developers
Back to course options
Rapid Website Development with Groovy and Grails
Instructor Name: Graeme Rocher
Course Level: Intermediate
Course Length: Half-day course (afternoon)
Course Description:
Grails leverages hugely popular frameworks such as Spring, Hibernate and SiteMesh simplifying them using a dynamic platform and "Convention over Configuration". More importantly, however, it takes integration with Java technology and the Java Platform, Enterprise Edition (Java EE) to a new level by bringing 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 with a whirlwind tour followed by a look at Grails, its features and its importance as an alternative platform for rapid web application development.
In addition, you will learn how to integrate Grails with existing Java technology enterprise services, databases and web applications and how to use a blended approach mixing static and dynamically typed code to maximise the scalability of your code base.
Course Approach:
This course introduces the Groovy and Grails, providing a basis for rapid web-application development. Leveraging these technologies, this course will show you how to setup and customize a dynamic Web site.
The demos for this course feature the NetBeans integrated development environment.
Content:
The Groovy Tour
- Groovy for Java Developers - The Basics
- The syntax similarities
- New language constructs
- Groovy Strings
- Closures
- What makes Groovy tick?
- Groovy dynamism
- Meta-programming
- Embedding Groovy
Getting started with Grails
- The 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 CRUD application
- Grails in-depth: The full stack
- 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 HQL
- Simple MVC with Grails
- Controllers for flow logic
- Tag libraries made simple
- Groovy views with GSP
- Adaptive Ajax tags
- Java Integration
- Java EE Platform Integration
- Packaging and deployment onto JEE containers
- Using EJBv3 component entities with Grails
- Grails and the Servlet environment
- Technology stack integration
- Wiring it all together with the Spring DSL
- Scripting Hibernate with GORM
Pre-requisites:
A good knowledge of web application development using languages such as Java or Javascript. 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 ORM layer
- Learn about Grails' MVC components
- Understand how to integrate Grails with existing Java technology components and services
Features of this course:
- Student will be provided with a printed copy of instructor slides.
- Instructor will be available for Q/A immediately following the course
Job roles this course is applicable to:
Web application Developers
Back to course options
Turbocharging Application Performance with DTrace
Instructor Name: Phil Harman and John Haslam
Course Level: Beginner
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 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 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 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 Solaris Kernel engineers.
- Instructor 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
Deploying Collaborative Websites to the OpenSolaris Operating System Using AMP
Instructor Name: Steve Maring
Course Level: Intermediate
Course Length: Bonus evening course
Course Description:
The Solaris Operating System (Solaris OS) has long been a leader in enterprise class server deployments. However, with the Solaris 10 release, and Sun's renewed emphasis on the support of x86 hardware architectures, the Solaris platform is starting to capture the attention of small business owners and Open Source project developers alike. To them, the Solaris10 release represents a ubiquitous migration path from development all the way to the dream of enterprise class deployment, without massive application refactoring for a clustered environment.
In an effort to encourage startup companies to use the Solaris OS, Sun has started amassing resources to support the development and deployment of web sites using scripting languages like PHP and Perl, and Ruby to the Solaris OS. These resources include prepackaged server processes, robust support forums and developer tools.
Course Approach:
This course is designed to show web developers and administrators how to deploy common collaborative environments to the Solaris OS. Using Coolstack, a collection of SAMP (Solaris, Apache, MySQL, PHP/Perl) packages optimized for performance and security on Solaris OS, and an optimized PostgreSQL package, attendees will learn how to quickly install and configure an environment to support a vast majority of "turnkey" PHP and Perl Open Source Web site projects. Attendees will then learn how to deploy and customize MediaWiki and Drupal for their own purposes.
Content:
- Getting Started with PHP
- Apache setup and configuration
- MySQL setup and configuration
- Collaborative Web site with MediaWiki
- Blogging Web site with Drupal
- Getting started with PostgreSQL
Pre-requisites:
A good knowledge of web application development using programming languages such as Java or JavaScript. Basic understanding of HTML and web technologies
Objectives
Upon completion of this course, participants should have an understanding of how to setup and customize a collaborative dynamic web site.
Features of this course:
- Student will be provided with a printed copy of instructor slides
- Instructor will be available for Q/A immediately following the course
Job roles this course is applicable to:
Web Application Developers
Back to course options
Digital Identity Trends and How to Realize Rapid RBAC Deployment
Instructor Name: Mark Dixon and Terry Sigle
Course Level: Intermediate
Course Length: Bonus evening course
Course Description:
Mark Dixon, Systems Engineering Manager for the US Communications Market Area in the Sun Software Practice, and Digital Identity thought leader, presents a cutting-edge look at the critical factors influencing the Digital Identity marketplace in the next 3 years. Research done throughout the identity community in early 2007 forms the basis for his conclusions.
Mark will also share his expertise in implementing Identity Management for the enterprise, highlighting rapid deployment methods for Role-Based Access Control (RBAC) using the Sun Velocity Identity Deployment Tool (VIDT). Rapid Identity Management Deployment is one of the key trends in the Digital Identity marketplace.
Course Approach:
This course covers a broad range of topics enabling participants have a clear understanding of the scope of Identity Management and its continuing expansion and change.
The demos for this course feature the Sun Java System Identity Manager software.
Content:
- What are the major drivers affecting the Digital Identity marketplace?
- What are the roles of enterprises, governments and individuals in this evolving market? What are the technology trends that will respond to the market drivers?
- How far will it go? Will we extend beyond operating systems, applications, directories and data bases to network devices and physical access control?
- How will deployment models improve and how will enterprises organize to effectively manage identities?
- What about the rise of User-centric Identity and customer-focused commerce models such as Vendor Relationship Management (VRM)?
- Then, as an example of one major trend, we will show you how to rapidly deploy Role-Based Access Control using the Sun Velocity Identity Deployment Tool (VIDT).
Pre-requisites:
Participants should have a a basic understanding of Digital Identity practices. Practical knowledge of the Sun Identity Manager tool would be helpful for the VIDT section.
Objectives
Upon completion of this course, participants should have an understanding of the upcoming changes that will impact how we use and implement identity management methods, and understand how rapid deployment of identity management systems can be accomplished.
Features of this course:
- Student will be provided with a printed copy of instructor slides
- Instructor will be available for Q/A immediately following the course
- Instructor will provide a basis for interactive dialog before and after the course on the instructor's blog: http://blogs.sun.com/identity
Job roles this course is applicable to:
Identity Management Architects, Implementors, and Integrators
Back to course options
Ruby on Rails for Java Technology Developers
Instructor Name: Stuart Dabbs Halloway
Course Level: Intermediate
Course Length: Bonus evening course
Course Description:
Ruby on Rails is a framework for quickly building web applications. Rails takes advantage of many of the lessons learned over the past decade of web development. Rails uses Model/View/Controller (MVC), view templates, sessions, cookies, and many other abstractions that developers in any web framework will find familiar.
But Rails improves on the past as well. With convention over configuration, you use configuration only where necessary, so simple applications do not require hundreds of lines of boilerplate XML.
In this session you will learn why Rails is so powerful, and why other frameworks are racing to emulate Rails' best features. Best of all, Ruby and Java technology are growing together. With JRuby, you can run your Rails apps on a Java technology-based VM, and continue to access the enormous base of useful Java libraries. You will see how easy it is to get an application started with JRuby on Rails.
Course Approach:
This course introduces the Ruby language and the Rails framework. In five minutes, we will build a database powered web application from scratch. But any pre-canned demo can do that. More important is what comes next. Rails applications are designed to make ongoing modifications simple. Within an hour, we can make modifications to the schema, model objects, views, controller logic, and Ajax.
The demos for this course feature the NetBeans integrated development environment.
Content:
- Ruby: A convergence of good ideas
- Ruby
- The interactive Ruby shell
- Core classes
- Reflection
- Ruby Eye for the Java Technology Guy: What makes Ruby so different
- Everything is an object
- OO goes meta
- Open classes
- Collections, procs, and blocks
- Rails in Five Minutes
- Migrations: agility for schema
- Scaffolds: getting started fast
- Structure of an application
- Support scripts
- Rails in One Hour
- Updating a schema
- Adding validations
- Domain-Specific Languages (DSLs)
- Adding relationships
- Modifying the view
- Using the flash
- Framework Comparison
- Modifying Controllers
- Ajax
- JRuby on Rails
- Getting started
- Calling Java
- Roadmap
Pre-requisites:
Web application development experience in some object-oriented language.
Objectives
- Learn the basics of Ruby
- Learn the basics of Rails
- See how Rails' use of convention over configuration simplifies web application development
- Explore the future of Java technology: JRuby
Features of this course:
- Students will receive a printed copy of instructor slides
- Instructor available for Q&A following the course
- Sample code available online
Job roles this course is applicable to:
- Web application developers
- Enterprise application developers
Back to course options
All courses subject to change
