ACM Logo

Joint ACM Java Grande - ISCOPE 2002 Conference

Seattle, Washington, November 3-5, 2002

Sponsored by ACM SIGPLAN


Call for Participation


  List of Papers
  List of Posters


Java Grande Charter

Related Links
Paper Submissions page

JGI'02 - Tutorials Program
Sunday, Nov. 3, 2002

  1. Programming the Grid with Java COG, Web Services and Component Software. Dennis Gannon (Indiana Univ.), Madhusudhan Govindaraju (Indiana Univ.), Sriram Krishnan (Indiana Univ.), Gregor von Laszewski (ANL), Alek Slominski (Indiana Univ.). Full day.
  2. Java for High Performance Computing. Sam Midkiff (Purdue Univ.), Roldan Pozo (NIST). Half day (morning).
  3. C# and .NET for Java Programmers. Judith Bishop (Univ. of Pretoria) and Nigel Horspool (Univ. of Victoria). Half day (morning).
  4. Process Oriented Design for Java: Concurrency for All. Peter Welch (University of Kent at Canterbury). Half day (afternoon).
  5. Network and Java Security Concepts. Raghavan Srinivas (Sun Microsystems). Half day (afternoon).
Also see the OOPSLA 2002 Tutorials

Title: Programming the Grid with Java COG, Web Services and Component Software
Lecturers: Dennis Gannon (Indiana University), Madhusudhan Govindaraju (Indiana University), Sriram Krishnan (Indiana University), Gregor von Laszewski (ANL), Alek Slominski (Indiana University)
Duration: full-day

Intended audience:
Software developers interested in designing distributed OO applications for Grid systems.

Experienced Java Programmers with a basic understanding of XML.

The goal of this tutorial is to describe how to build distributed applications on Grid systems. A Grid is a framework of ubiquitous services that allow a community of collaborators to share computational and data resources in a secure environment.

This tutorial will describe how to build Grid applications using three closely related technologies:

  1. The Java COG Kit, which provides a widely-used interface to the Globus Grid software,
  2. Web Services, which form the foundation of the emerging Open Grid Services Architecture
  3. Distributed software components, which are built on top of COG and OGSA Web Services.

Lecture outline:

  1. An introduction to the Grid - what does it look like? What are the applications?
  2. Java Cog Basics
  3. Java Cog Advanced Programming
  4. Basic Web Service Concepts
  5. Advanced WS Concepts: Workflow management and composing services
  6. Software components and OGSA
  7. Building a Grid Portal

Brief CVs:
Dennis Gannon is chair of the computer science department at Indiana University. He has been active in Java Grande and the Global Grid Forum from the beginning. He is also a PI on the Center for Component Technology for Terascale Systems and Software

Gregor von Laszewski is an Assistant Computer Scientist at Argonne National Laboratory, a Fellow of the Computation Institute at University of Chicago and a Visiting Professor at Illinois Institute of Technology. He is the chief architect of the Commodity Grids Toolkit (COG).

Madhusudhan Govindaraju is a Postdoctoral Scientist at Indiana University. He is the co-designer and developer of the XSOAP C++ system and the XCAT distributed component system.

Sriram Krishnan is a Ph.D. student in Computer Science at Indiana University. He has designed large scale distributed applications using XCAT and the XCAT Science Portal.

Alek Slominski is a Ph.D. student in Computer Science at Indiana University. He is the co-designer of XSOAP, XMP - the XML pull parser and has worked on a variety of Web Services technology while at IBM Watson Research Labs.

Title: Java for High Performance Computing
Lecturers: Sam Midkiff (Purdue University), Roldan Pozo (NIST)
Duration: half-day

Intended audience:
Skilled Java technology-based software developers, engineers, programmers, analysts, architects, and computational scientists

Hands-on Java programming language experience is required. Understanding of distributed computing and object-oriented programming is required.

This course will discuss in detail how to use Java for tasks requiring high-performance computing. The course is intended for developers and computational scientists experienced in using Java technology. The course will cover three main areas:

  • How to use Java in applications that require enhanced numerics
  • How to design and implement optimizing compilers to achieve high performance
  • How to design distributed high-performance applications that use well-established programming paradigms


  • Highlights current trends in the use of Java for high-performance computing.
  • Introduces Java numeric issues, including efficient multi-arrays and complex numbers, efficient numerical calculations in Java, and Java numerical libraries.
  • Compares the performance of Java with C/C++ and Fortran.
  • Discusses how Java can be used for distributed computing, including use of message-passing libraries and distributed computing with remote objects.

Lecture outline:

    * History
    * Parallel programming paradigms
    * High-performance and distributed computing challenges
    * Current trends in the high-performance computing community
    * Introduction to Java for numerical computing
    * Bit-wise reproducibility of floating-point results
    * Multi-arrays
    * Complex numbers
    * Transcendental functions
    * Numerical libraries
    * Performance analysis
    * Comparison with C/C++ and Fortran
    * Optimizing BLAS kernels
    * Java numeric benchmarks
    * General performance improvements
    * Java vs. Fortran array data structures
    * The Array package for Java
    * Compiler optimizations
    * Performance results
    Distributed programming with message based libraries
    * MPI
    * openMP
    * JMS

Brief CVs:
Sam Midkiff, Purdue University
Dr. Samuel P. Midkiff received a Ph.D. in Computer Science from the University of Illinois at Urbana-Champaign in 1992. From then until July of this year he was a research staff member at the IBM T.J. Watson Research Center, and is now an Associate Professor in the Dept. of Electrical and Computing Engineering at Purdue University. His current research interests are the interplay of compilers, programming language memory models and hardware consistency models; compiling for low power; compiling for reliability and ease of use; and exploiting Java compilation models to enable advanced optimizations.

Roldan Pozo, National Institute of Standards and Technology
Roldan Pozo leads the Mathematical Software Group at the National Institute of Standards and Technology, where he investigates issues in high performance scientific computation, numerical linear algebra, and software environments and tools for parallel computing. He is the principal designer of several C++ numerical linear algebra libraries, including Lapack++, SparseLib++, MV++, IML++, and the Template Numerical Toolkit (TNT). He is also coauthor of the book, "Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods", and one of the developers of Matrix Market.

Dr Pozo received his PhD in Computer Science from the University of Colorado in 1991, and in 1997 was awarded the Presidential Early Career Award from the US White House for his contributions in object-oriented linear algebra software and computing. Currently, he is investigating portable high-performance computing with Java and is co-chair of the Java Numerics Group. Dr. Pozo is also an Associate Editor of the ACM Transactions on Mathematical Software.

Title: C# and .NET for Java Programmers
Lecturers: Judith Bishop and Nigel Horspool
Duration: half-day

Intended audience:
The tutorial is aimed at people with no experience of C# but with some experience of Java who want to find out what it is all about and how it can affect their lives as Java users.

A new language brings with it new opportunities and challenges. Yet programmers cannot easily let go of investment in an existing language. We are faced with this dilemma with C# and Java. Is it worth moving to C# and what would be the benefits? On the other hand, can the two languages co-exist, enabling us to take the best from both? Here we will give insight into both answers.

This tutorial looks at the best features of C# and how they can be incorporated seamlessly into programs, even those that are currently based on Java. Language features covered include value and reference types, overloaded operators, collections and the foreach loop. Several advanced oops features are implemented in C# in a novel way, and make life easier for the programmer. Those mentioned here are properties, reflection and serialization on the net via XML and SOAP. Several examples will be examined and source code will be made available to the attendees.

C# comes along with the .NET environment which has to be taken into account as soon as one moves to net-centric computing. .NET is based on server side processing, and the central role of the Common Language Runtime (similar to Java's JVM) means that languages outside it could well be excluded in the future. Java is outside the CLR and therefore Java programs must either be converted to Microsoft's J# language or be linked to other .NET programs. We have investigated how such linkage can be accomplished. We show how C# can be used to mimic the client side processing of an applet and how it can be called from Java. Reference is made to work on a platform independent XML-based GUI generator (available for both C# and Java), which can free programmers from additional Microsoft software, i.e. the forms designer of Visual Studio. Some of the examples are run on Microsoft's Open Source C#, called Rotor, which is available on FreeBSD Unix in addition to Windows XP.

Lecture outline:

  • Exciting new features of C#, as compared to Java
  • Case studies of programs in C#
  • Outline of .NET and the CLR
  • Linking Java and C#
  • Platform-independent GUI generator

Brief CVs:
Judith Bishop is a Professor of Computer Science at the University of Pretoria, South Africa. Author of 12 books on languages including Java. Immediate past chairman of IFIP WG2.4 (Software Implementation Technology), author of over 50 papers, on several program committees including Compiler Construction 2002 & 2003, Net Object Days 2002, Component Deployment 2002 and JavaGrande 2002.

R Nigel Horspool: Professor and Head of Department of Computer Science, University of Victoria, Canada. Author of two books on C and Unix. Immediate past chairman of Compiler Construction 2002. Author of over 60 papers, member of 2 program committees: Compiler Construction 2003 and Component Deployment 2002.

Bishop and Horspool are authors of an upcoming book on C# to be published by Addison-Wesley in March 2003, and are holders of a Microsoft Research Rotor Grant.

Title: Process Oriented Design for Java: Concurrency for All
Lecturer:P.H.Welch, University of Kent at Canterbury.
Duration: half-day

Intended audience:
Anyone designing and implementing systems for which concurrency is an essential element (which includes high performance, distributed and dynamically networked systems).

Concurrency is thought to be an advanced topic - much harder than serial computing which, therefore, needs to be mastered first. This tutorial contends that this tradition is wrong, which has radical implications for the way we educate people in Computer Science - and on how we apply what we have learnt.

A process-oriented design pattern for concurrency is presented with a specific binding for Java. It is based on the algebra of Communicating Sequential Processes (CSP) as captured by the JCSP library of Java classes. No mathematical sophistication is needed to master it. The user gets the benefit of the sophistication that underlies CSP simply by learning the patterns and using the library. Those benefits include simplification wins for design and implementation that concurrency ought always to have made possible, but with the approaches used before somehow did the opposite. And we don't lose the performance wins for grand-challenge and reactive systems that have been our traditional reasons for going parallel.

Although the Java binding to CSP mechanisms is new, fifteen years of working with students at Kent have shown that the ideas within process-oriented design can be quickly absorbed and applied. Getting the ideas across as soon as possible pays dividends - the later it's left, the more difficult it becomes to wean people off those serial ways of thought that fit many applications so badly. Concurrency for all (and for everyday use) in the design and implementation of complex, maintainable and scaleable computer systems is both achievable and necessary.

This tutorial will also introduce the JCSP Network Edition, which extends the same CSP concurrency model to networked systems. This enables the dynamic distribution and connection of JCSP processes with no central or pre-planned control (although that is easy to impose when necessary). Details of the underlying network fabric and control (such as multiplexing, flow-control, network addresses) are hidden from the JCSP programmer, who works entirely at the application level using CSP communication and synchronisation primitives. Indeed, processes themselves need not be aware that they are networked, which enables simple re-configuration and load balancing. The seamless unification of external and internal concurrency mechanisms, the dynamic construction (and de-comstruction) offered for networked applications and the formal compositional basis of the underlying CSP model (which may be ignored by users or employed directly for formal analysis and/or model checking) are significant (we argue) advances on the current state of the art.

Key URLs:
JCSP home page
Commercial support

Brief CV:
Peter Welch graduated in Mathematics from Warwick University in 1969, taking his Ph.D in Computer Science from the same institution in 1974. His doctoral research was on semantic models for the lambda-calculus, one of the key mathematical theories supporting functional programming. For the past 15 years, his main area of research and teaching has been in the field of parallel computing. He has made contributions to theoretical developments (e.g. CSP-based design rules for process network hierarchies with proven safety properties such as the absence of deadlock, livelock and starvation), tools supporting those rules, compilers for parallel languages, very lightweight CSP kernels (with sub-microsecond process management) and, recently, the CSP class libraries for Java. He has also worked on applications in the areas of real-time control, vision processing, networking and biological/physical system modelling. He has recently been working on design rules for eliminating race-hazards from shared-memory multi-processing in the presence of dynamic memory allocation, higher level synchronisation primitives, SMP multi-threading kernels and the exploitation of these ideas in the Java world.

He was appointed Professor of Parallel Computing at the University of Kent at Canterbury (England) in 1989). He led the UK-funded "occam-for-all" project (1995-97) which has ported the CSP-derived occam multiprocessing language to a variety of modern parallel architectures. occam, because of its simplicity, security, lightness and formal semantics, remains a key research tool with relevance to the Java community as it struggles to come to terms with the problems and opportunities of multithreading. Professor Welch is one of the leading advocates for the transfer of technical knowledge from the mature CSP community into the wider world of parallel computing, where the lack of basic theory and tools is an admitted problem and a serious obstacle to practice.

Title: Network and Java Security Concepts
Lecturer: Raghavan "Rags" N. Srinivas, Sun Microsystems
Duration: half-day

Intended audience:

Some Java programming would be useful.

Java with it's Write Once Run Anywhere philosophy is fast becoming a de facto platform of choice for development and deployment of enterprise solutions. With Java being available from Smart Card to Super Computers, it lends itself for implementing portable security solutions. Security, which is a critical need in today's networked economy has been one of the overriding requirements in the design of the language.

This session will discuss the basics of network security, the variety of infrastructural support and the choice of ready solutions in Java towards building secure products. The mission of this session is to drive home the point that developers need to understand security, and surprisingly, the concepts are quite simple. The following topics will be covered with some very simple code samples.

Lecture outline:

        Network security concepts       45 mins.
          - Message Digests
          - Digital signatures
          - ciphers and
          - Public Key Infrastructure (PKI)
        Java Security
          - Evolution                   10 mins.
          - Java security tools         10 mins.
          - Java Applet Security and code signing
            - code signing using standard CAs   20 mins.
            - code signing using test CAs               10 mins.
          - Java Optional packages
            - Java CertPath     10 mins.
            - JCA/JCE           15 mins.
            - JSSE              15 mins.
            - JAAS/JGSS         10 mins
          - XML Security               15 mins.
          - Futures                     5 mins.
          - Q&A                        15 mins.

Brief CV:
Raghavan "Rags" Srinivas is a Java Technology Evangelist at Sun Microsystems. He specializes in Java and distributed systems. He is a proponent of Java technology and teaches undergraduate and graduate classes in the evening. He has spoken on a variety of technical topics at conferences around the world.

Rags brings with him about 15 years of software development experience. He worked for Digital Equipment Corporation before joining Sun. He has worked on several technology areas, including internals of VMS, Unix and NT.

Rags holds a Masters degree in Computer Science from the Center of Advanced Computer Studies at the University of Southwestern Louisiana.

He enjoys running, hiking and eating spicy food.


Home |CFP (TXT) |People |Charter |Related Links | Webmaster: