Bruce Eckel Presents:

Thinking in CORBA with Java:
A 5-day, Hands-on Intensive Workshop
Taught by Dave Bartlett
(author of the upcoming book of the same title,
and IBM's DeveloperWorks CORBA Junction column),
hosted by Bruce Eckel

Not Currently Scheduled

For technical questions and information about in-house training, consulting, and offsite development services, email dbartlett@pobox.com

By now, you're probably all too familiar with the risks and problems of tying yourself to the technology of any particular vendor (no names necessary here!). This is a particularly important issue when considering a "Common-Object" architecture. We feel CORBA, as an open standard with multiple implementations, is the best bet, and the wave of the future, and that's why we created this seminar.

Here's why you'll want to come!

Get thorough coverage of the Common Object Request Broker Architecture from fundamentals to ORB portability to advanced topics.
Most other courses focus on a specific ORB, we will focus on creating portable distributed components with Java. This course will examine CORBA with Java and the portable nature inherent in that combination of architecture and language. We use the free-to-download, 2.3 compliant ORB from Object Oriented Concepts, Inc.'s Orbacus ORB or Inprise's Visibroker which is also 2.3 compliant and free to download with a 60 day evaluation period.
Yes, you should know Java. We will be covering CORBA, not Java. If you need Java instruction first try Bruce Eckel's Hands-On Java Seminar or the Seminar-on-CDROM. As an alternative, if you have used C++ and CORBA then you should be fine.
You will Learn CORBA from an object-oriented perspective. This includes abstracting interfaces from implementation, inheritance and using Design Patterns.
Taught personally Dave Bartlett, the creator of the seminar, and hosted by Bruce Eckel (author of Thinking in Java). This course is designed with years of background teaching seminars, consulting in object-oriented programming and designing distributed systems. We are dedicated to giving you the best learning experience possible.
Hands on! We will set up a network in the classroom, enabling you to use your own laptop to hook to our server and participate in our distributed system. In-class programming exercises mean you'll walk away with confidence in your programming and architectural skills after 5 fun days.
The insight you'll gain into the essentials of the CORBA Architecture and Java language will allow you to focus on the real problems involved in system design, component development and language issues so you can get your project moving in the right direction.
Get up to speed quickly: a five-day investment saves many months of learning things the hard way!
Get an independent perspective: Bruce and Dave are mentors/consultants who do not work for Sun Microsystems, OMG or any other architecture or Java language vendor. Dave has 10 years experience working with DCOM as well as CORBA.
Learn the advantages and disadvantages of development using CORBA with Java. Learn about the different ORBs and how to make your servers and clients as portable as possible. Learn about third-party tools.
Covers technical information not included or only lightly touched by the on-line documentation and many books.
Shorten your development time with a thorough understanding of CORBA, the Java programming language and all the related technical jargon.

Comments from students:

Click here for more into on 'Mindboggling CORBA Made Easy' Training Course! Raghavender Gyambavantha - Ericsson Wireless
Well organized class. Great personal attention. Charles Bier - Ericsson Wireless
Lots of info! Hands-on exercises help it to sink in. I'm sorry I missed the hikes. Peter Silsbee - Ericsson Wireless
Great way to dive deep into CORBA and have good feelings about it after. Thank you, Dave. Alexandra Zasimova - Ericsson Wireless
Good way to get started on CORBA. Wrote & tested my first client/server in one day. Embedded programmer - Ericsson Wireless
Highly recommended for any one involved in CORBA design. Harry Pellegrino, DirecTV Latin America
It was a wonderful experience! Atul Bansal - DirecTV Latin America
This course is a knowledge transfer session that provides students with key information to enable them to learn and beg for more CORBA technology. Jorge Luis Mejia - DirecTV Latin America
It puts you up to speed in CORBA with Java in one week. Jose Rojas, DirecTV Latin America
Dave's in-depth knowledge of CORBA was a great teaching tool. "Thinking in CORBA" covers not only CORBA, but real world situation of where CORBA can be utilized. This course is a great way to get up to speed on CORBA. Jason Jensen, Software Engineer - DirecTV Latin America
Great! Learned a lot. Very productive mixture: learning a lot of stuff in the morning. Free up your mind during wonderful hikes through terrific scenery in the afternoon. Coming back and learning even more with a freshened mind. Heiko Kolter, FJA - Innosoft, Germany
Great seminar, great location, great atmosphere. Lots of information, very well taught. Andreas Mock, FJA - Innosoft, Germany
This was an intensive, hands on seminar - as advertised - with plenty of techniques that can be applied immediately to solve business problems. Anonymous
Good introduction to CORBA. Good programming examples and exercises. Rajesh Joshi, Ericsson
Java, coffee, hikes, oh btw CORBA, what more can you ask for? Rags Srinivasan, Ericsson
It has been a great experience. Dave and Bruce are great teachers, and they really know their stuff. Yufeng Liang, Broadvision, Inc.
A well organized and complete introduction to CORBA in the best learning environment in the world. Mark A. Russell, CTO, Ceon Corporation
The Hands-On CORBA/Java seminar was a great experience. Bruce, Dave and Andrea are exceptional trainers and can explain some of the most difficult and challenging topics in a very easy-to-understand manner. Not only did we get hands-on experience with CORBA, but Bruce also led several "guided" hikes/tours through the mountains. This seminar was by far the best technically and recreationally I have ever experienced. Dale P. Olzer/AT&T Wireless Services (AWS)
Great team. The range of knowledge covered by Bruce, Dave, and Andrea is incredible. I also liked the fact that there was little "religion" discussed at the seminar. By far, the best seminar I have ever attended. Bill Mooney, Software Engineer, Reuters Inc.
An excellent, vendor-independent CORBA introduction. The hands-on nature of the class allowed me to feel confident in designing and writing a CORBA-based system. Mike Bopf — Senior Software Engineer, AppNet, Inc.
I gained insight that would have required countless hours of my own research. The lab assignments gave me a level of confidence that will be a strong foundation on which I can build. John Crabtree/Software consultant
I gained insight that would have required countless hours of my own research. The lab assignments gave me a level of confidence that will be a strong foundation on which I can build. John Crabtree/Software consultant
It was a great learning experience. It saved months of learning by trial and error. The instructors were very patient and knowledgeable. Highly recommended! Fred Trimble / Acticum Corp.
Made an often-confused object technology very easy to grasp! Keith Bowman, System Analyst
The Hands-On CORBA/Java seminar has proven to be a very rewarding mix of lectures and labs that enables the attendee to leave feeling confident that he/she has achieved a reasonably high level of understanding. Jonathon Eagles, Senior Consultant with Cornerstone Consulting, Inc.
I came in knowing virtually nothing about CORBA, but I'm leaving confident I can implement applications utilizing it. Stephen Phillips, Computer Analyst, Survice Engineering
I asked for CORBA cultural immersion and that's what I got. Tish Weisser, Phoenix Home Life Mutual Insurance Company
Great Hikes, good coffee, very personable trainers.
Excellent overview of emerging technology. Locale for class was great.
This course taught in one week more than I had learned about CORBA in two years of trying to grasp it on my own. We attained the summit and met my goals — but Bruce and Dave also taught well that this peak is only the tip of the iceberg. I know now that I can do CORBA, and that I have much more to learn. Michael Oliver, Senior Specialist, Compuware Corporation
I now feel much more comfortable opening any document about CORBA. I know I'll refer to my notes from this class. It met my expectations. Frank Bender, Software Consultant
Exceptionally clear and sharp explanations, well-graduated exercises to practice what you have just learned. It covers the lack of documentation about CORBA. In my opinion it is the "best buy" course when you have to deal with CORBA in short times. Discussions about design methodology also raised during the lessons were so interesting I think they have to be taught as an extra value. Luca Debiasi — Teleporto Adriatico, S.R.L., Italy
What I learned in this class would have taken me months of research, trial and error. That's time I just don't have to spare. Dave Klein, Independent Consultant
This course is a great "kick-start" for Java programmers to learn what CORBA is and to implement some client-server solutions using Java and CORBA. A unique approach that gives an overview and practical implementation experience. Rich Bagley — Sprint
A great jump-start into the CORBA world with enough detail to provide insight to those already familiar with CORBA. Janet Tvedt, Scientific Programmer, National Solar Observatory
Knowledgeable, professional and informative without being formal and dry. Eric Barr, EricBarr@CyberServices.com
... a great course for a Java/CORBA introduction, and in a GREAT location!

What you'll learn

This course has come together because of the convergence of two technologies. The Object Management Group's CORBA 2.3 specification (and soon 3.0) has a more finely defined ORB in which portability takes a high priority. The Java programming language was designed with portability in mind. These two terrific technologies, when used correctly, will enable you to create distributed systems that are ORB neutral. No longer will you have to ask "Which ORB are you using?"

Most CORBA courses that you see will focus on one ORB or another. Not this course. We will teach CORBA and Java with the focus on interoperability and portability. The Internet Inter-ORB Protocol (IIOP) specification allows a client application written with one vendor's ORB to interoperate with a server application written with another vendor's ORB. The IDL-to-Java language mapping takes the notion of cross-vendor interoperability further by calling any client application to be run on any compliant ORB implementation.

This means Binary Compatibility. A CORBA applet using Sun's ORB can later be deployed to utilize the compliant Visibroker ORB presently shipping with Netscape Navigator without changing any code. This allows developers to build applications that are not dependent on a single vendor's ORB implementation. For many internally developed products this may not be an issue due to corporate standards; however we feel these topics will cross every developer's mind due to the systems integration needed after mergers and acquisitions and the need for interoperability between multiple versions of a single vendor's ORB.

Here are the sessions in the sequence they'll be presented. Note that most of the sections are followed by a lab period with an integrated break that may also mean "lunch," depending on when the lab period occurs.

Session 1: Why Choose CORBA and Java

This session is an overview of what distributed systems are all about. Why should you implement a distributed system? The benefits and challenges of using CORBA with Java.

Session 2: A simple example

Gets the course rolling with an example that puts all the pieces in place and forces us to start using the terminology correctly. Different people, including authors, organizations and periodicals, use terminology loosely. Terms such as object, class, and interface denote different meanings depending upon context. We will use this simple example to force these issues to the front and give us common terminology for the remainder of the course.

Session 3: Under the Hood& Design

A close look at what goes over the wire. We dip into the alphabet soup of protocols: GIOP, IIOP, CDR, and IOP. This will give a solid foundation to understand all that goes on above these protocols.

Session 4: IDL

Understanding IDL is crucial for being able to create distributed systems. This is true for CORBA, DCE, and DCOM. This session more than any other will provide you with transferable skills for building distributed systems. The syntax and semantics of IDL will be thoroughly detailed along with analysis and design issues.

Session 5: IDL to Java Mapping

The ability to create clients and servers that are portable rests with the IDL-to-Java compiler that is used to produce the Java language constructs from the IDL. This is done with a Java IDL compiler. For Visibroker this would be idl2java.exe and for Sun it would be idltojava.exe. The mapping should be rather generic for any conforming IDL-to-Java compiler but we will examine the difference in the output of these two compilers. Some of the topics will examine Reserved Names, Basic Types, Sequences and Arrays, Interface, Exception, AnyType, Holder and Helper Classes, and server-side mapping.

Session 6: Object Request Brokers

Central to CORBA is the Object Request Broker (ORB). We will not look explicitly at any ORB but will instead examine ORBs in general. We'll explore the structure of an ORB and the different ways to implement ORBs such as client, implementation-resident, server-based, system-based, and library-based. We will also look at ORB portability and the structure of a Portable Object Adapter (POA), and the ORB interface in detail.

Session 7: Locating Objects

This session looks at how objects are located using the Naming Service and the Trading Service. Both of these services are widely used and having a detailed understanding of object location is crucial for creating enterprise systems. Examples of creating NamingContexts and publishing Object References will be examined.

Session 8: Server Mechanics

Server developers need to understand many distinct yet interrelated topics. The learning curve is long and steep but we shall try to shorten it by focusing on topics such as the Portable Object Adapters, object naming, object activation and factories, and the interplay between ORBs. Concepts will include error handling, garbage collection, load balancing, threading, interceptors, and object persistence. Portability will also be addressed in this section as each different ORB implementation imposes its own perspective on many of these topics.

Session 9: Client Choices

The client is the target of this technology. It is the client that must obtain at least one object reference and invoke operations upon CORBA objects. The client's responsibilities include locating services, obtaining initial references, and handling exceptions raised from the remote method invocations. The client also has the choice of going static or dynamic, therefore we will look at Dynamic Interface Invocation and the Interface Repository will be introduced.

Session 10: CORBA Services

An examination of the CORBA Services. We cannot possibly go into the details of all the services but we can cut the learning curve down to size by going over the general design principles used to develop a CORBA Service. We will explain what many of the services are trying to do and how to start using them by reading their interfaces. The service we focus on is the Event Service.

Session 11: Security

Security has become a huge topic in the distributed environment and the OMG has led the way in providing a cutting edge security specification. We will look at the important topics included in this specifiction and stress the areas you should understand when implementing security into your project.

Thinking In CORBA with Java:
The Book

Yes, there will eventually be a book, and it will be freely downloadable from this site. Right now, however, we are concentrating on the seminar. If you'd like to be informed about when the book will be on the website, subscribe yourself to the free newsletter. Your feedback will be crucial to helping us write the best book possible.

Prerequisites

This will be an intense learning experience, and you'll need to have a good grasp of Java before you come.This course assumes you have programming experience with Java or the C or C++ language syntax. If you haven't been exposed to C or Java, download Thinking in Java and get to work. Of course, the seminar will be easier for the experienced Java and C++ programmers because they have the object understanding and experience, but if you're not already comfortable with either of those, just plan to study Java before you come. We will be assuming you understand the concepts of object-oriented programming. If you need to prime your skills try the following:

Bruce Eckel's Hands-On Java Seminar or
Cover the material in Thinking in Java or
Listen to the lectures on Bruce Eckel's Hands-On Java CD ROM

This is a challenging course; we'll move through all the features of an extremely complex architecture, with exercises, in five days. Our goal is to give you enough learning experiences to push you to your limit, but not beyond. Sort of a "CORBA Cultural Immersion." You should come away tired but happy and dreaming Distributed Object Models.

What to bring

Your notebook computer with Windows 95/98 or Windows NT (Java only works on a 32-bit platform). There will be power cords and power strips provided on site.

A network card and a twisted pair interface ("10-Base-T": the one that looks like a wide phone jack). (We will supply the server, the network hub and the cables.)

Please pre-install and test the latest JDK from Javasoft on your computer. You can download the JDK from java.sun.com and please test it by compiling and running the tutorial HelloApp.

Bring your Windows95/98 CD (your computer may already have the contents of the CD on the hard disk). This is necessary because you'll probably need to change your network settings in order to network to server.

You should pre-load the free-to-download, 2.3 compliant ORB from OpenORB or Object Oriented Concepts, Inc.'s Orbacus ORB or Inprise's Visibroker which is also 2.3 compliant and free to download with a 60 day evaluation period.

Download and install the JDK from http://www.javasoft.com/ and your favorite editing environment. Please test it by compiling and running the tutorial example HelloApp.java from Thinking in Java.

CORBA/Java Seminar