IEEE TRANSACTIONS ON EDUCATION, VOL. 50, NO. 1, FEBRUARY 2007
3
Teaching Grid Computing: Topics, Exercises, and Experiences Jens Mache and Amy Apon
Abstract—Grid protocols and technologies are being adopted in a wide variety of academic, government, and industrial environments, and a growing body of research-oriented literature in grid computing is being compiled. However, there is a need for educational material that is suitable for classroom use. This paper describes topics, exercises, and experiences of teaching grid computing at two different universities. Course material in grid computing can be grouped into several knowledge areas. The focus in this paper is on grid programming, i.e., developing grid-enabled services using the Globus toolkit. Assessment data shows that with preparatory material and hands-on exercises, undergraduate computer science students can master grid programming. Topics and exercises for security, network programming, Web services, and grid programming are described. Recommendations include using stand-alone containers on individual student computers and following a first grid programming exercise that builds confidence with at least one more elaborate grid programming exercise. Index Terms—Computer science education, Globus toolkit, grid computing, grid programming, high-performance computing, network programming, security, Web services.
I. INTRODUCTION HE three major thrusts of scientific research are 1) scientific experimentation, including laboratory and field experiments, 2) analytical and theoretical research, and 3) the use of computation to understand and solve complex problems. The U.S. federal government has recognized the importance of encouraging the third thrust. The 2005 President’s Information Technology Advisory Committee report specifically encourages the growth of “computational science,” or the use of computers to complement experiments and theoretical research [1]. Because of the importance of computational science, grid computing is a very important area of education. Grid computing is the technology that allows remote access to supercomputing resources for computation and large-scale data pro-
T
Manuscript received October 10, 2005. This work is supported by the National Science Foundation under grants DUE 0411237 and DUE 0410966. Allocation and accounts on the Teragrid are supported by the National Science Foundation under the following NSF programs: Partnerships for Advanced Computational Infrastructure, Distributed Terascale Facility (DTF), and Terascale Extensions: Enhancements to the Extensible Terascale Facility. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the National Science Foundation. J. Mache is with the Department of Mathematical and Computer Science, Lewis & Clark College, Portland, OR 97219-7899 USA (e-mail: jmache@ lclark.edu). A. Apon is with the Computer Science and Computer Engineering, University of Arkansas, Fayetteville, AR 72701 USA (e-mail:
[email protected]). Color versions of one or more of the figures in this paper are available online at http://ieeexplore.ieee.org. Digital Object Identifier 10.1109/TE.2006.890543
cessing. It includes the collection of hardware and software resources that allows researchers everywhere to access the fastest computational resources in the world. The next generation of scientists and engineers needs to prepare for a technological workplace that includes grid computing. This paper describes how grid computing has been taught at two different institutions over several semesters and at summer short courses and relates the conclusions and suggestions for teaching grid computing that have been gained by these experiences. The experiences have led to the identification of five knowledge areas for grid computing, the development of teaching modules and exercises, and recommendations for teaching grid computing. The paper is structured as follows. Section II describes five knowledge areas for grid computing. Section III describes topics and exercises for a course in grid computing that focuses on grid programming using the Globus toolkit. The section includes a discussion of teaching experiences and the results of student self-evaluations. Section IV is a discussion of the changes made as the Globus toolkit (GT) has matured from version 3 to version 4. Additional topics and an assessment of a GT4 exercise is presented in this section. Finally, Section V summarizes the conclusions and recommendations to instructors. II. GRID COMPUTING KNOWLEDGE AREAS During summer 2003, an experiment was performed to construct a grid between the two participating institutions and, concurrently, to study the level and complexities involved in learning grid computing required by a graduate and an advanced undergraduate computer science student. The starting point for the students included approximately Bachelor’s-level knowledge of computer science, particularly in the area of operating systems, basic networking concepts, basic distributed systems concepts, and Java programming. The graduate student had previously completed a graduate course in operating systems. The hardware resources included a small set of Pentium-based computers and some Fast Ethernet switches to the campus networks. During a one-month period, the goal was to install and configure three clusters at the two institutions and to run an MPI program using grid protocols across the available resources. One of the first steps in the experiment was to determine which suite of software packages would be used. The Globus toolkit [2] was selected as the primary grid development environment. At the time, the Open Grid Services Infrastructure (OGSI) document version 1.0 [3] had just been released as a standardization of grid computing towards grid services, and version 3 of the Globus toolkit had just been released as an
0018-9359/$25.00 © 2007 IEEE
4
IEEE TRANSACTIONS ON EDUCATION, VOL. 50, NO. 1, FEBRUARY 2007
Fig. 1. Proposed grid computing knowledge areas.
implementation of OGSI. Another significant factor was that although there were no “grid programming textbooks” available, the Globus Toolkit Programmer’s Tutorial (now available in book form [4]) and other materials at the Globus website were a readily available set of tutorial materials that seemed to fit the needs of the experiment. The Globus Toolkit 3 (version 3.0.1), Java 2 Platform Standard Edition (j2sdk-1.4.2), OSCAR (version 2.2.1), and MPICH-G2 (version 1.2.5-1) were selected. At the time of the experiment, these tools were the latest releases that would interoperate with each other. In addition, Red Hat Linux was freshly installed on each of the computers at the start of the month, using default configurations. The students were directed to the online training and grid development materials at the Globus website. The experiment was repeated in part with a group of four graduate and two undergraduate students taking an independent study in grid computing at the University of Arkansas, Fayetteville, during fall 2006. The experiments illuminated the complexities involved in learning grid computing and demonstrate that future grid workers must have knowledge in several specialized task and knowledge areas. Based on the observations, five areas of knowledge for grid computing are proposed, as shown in Fig. 1. The identified knowledge areas are independent of the specific details of the tools that have been selected. The knowledge areas are largely independent of each other. For example, a student does not need to know how to install and configure a grid development environment such as the Globus toolkit prior to using or writing a grid application. The only necessary factor is that the environment be provided for the student’s use. Similarly, a grid programmer need not be a parallel programmer. Parallel programming is generally taught as a complete course of its own, but it is included in the knowledge units here for completeness, since many applications running on the grid use parallel programming techniques. One of the conclusions from this initial experiment is that formal training appears to be required for undergraduates to learn grid computing. While the graduate student in the experiment was able to complete tasks in all five knowledge areas based on the Globus toolkit, the undergraduate, though highly qualified, fell short of this goal. He was able to install the cluster using the OSCAR toolkit and to begin the installation of the Globus toolkit (area 1 above). However, he did not progress to
the point of implementing security or using and creating a grid application using the Globus toolkit in the time allowed. The difficulties appear to be related to the presentation of material and the preparation of the student, rather than the capability of the student. Material on grid computing is filled with a long list of new acronyms and new applications. For example, a brief reading of the website for the Globus toolkit includes acronyms such as GT4, SOAP, WSDL, XML, GSI, and many more. As another example, sophisticated knowledge of Linux is required for implementing security, for configuring the network, for locating various configuration files, and for installing software, little of which is taught in a typical undergraduate curriculum. In general, the prerequisite knowledge for configuring the Globus toolkit was not clearly specified. The graduate student, having had more broad and advanced computer science training, was able to find background material and read it as needed. The graduate student was able to function at a level that is comparable to the professional audience for which the tutorial material is designed. However, the undergraduate was overwhelmed by the daunting array of prerequisite knowledge and new material. III. INITIAL SET OF GRID TOPICS AND EXERCISES FOR UNDERGRADUATES After this initial experiment, the next step was to identify the grid computing topics that are appropriate to be taught to undergraduate students and to present the material in a format that is suitable for classroom instruction. The focus has been on grid security and grid programming (areas 2 and 3 in Fig. 1). Grid computing courses were taught during the fall semester 2004, during summer 2005, and again during fall 2006. The audience included undergraduate computer science students at a small, private liberal arts college (Lewis & Clark College, Portland, OR) and a mix of undergraduate and graduate computer science students at a large, public Ph.D.-granting research university (University of Arkansas). Both courses have Web pages without access restrictions [5], [6]. Some material has been derived from earlier work [7], including a short unit on cluster computing [8], and from material that was developed by Wilkinson and Holliday [9], [10].
MACHE AND APON: TEACHING GRID COMPUTING: TOPICS, EXERCISES, AND EXPERIENCES
A. Topics Grid computing is a complex subject that uses knowledge from a diverse set of computer science background topics. Even focusing only on grid security and grid programming could use background knowledge of operating systems, software engineering, distributed systems, object-oriented programming in Java, network programming, XML schema, encryption, authorization, authentication, asynchronous process management, and others. The complete list of these background topics is much more than can be assumed as prerequisite knowledge to a course in most undergraduate curricula. With such a list of prerequisites, students would not have time to take the course before graduation. The assumption is that an undergraduate computer science student will have had a set of core courses that minimally includes data structures and one year of programming. Given this background, topics appropriate for grid security and grid programming at the undergraduate level can be identified. Although the belief is that knowledge areas can be developed independently of the use of a particular toolkit, the specific implementation of these knowledge areas depends on the use of specific programming tools and environments. The list has been developed in the context of the particular toolset that was used, which included Globus toolkit and associated software. Similar topics would be able to be developed for another toolset. 1) Topics for Grid Security: Topics for grid security have been relatively stable since the course was first taught in 2004. Topics for this area include the following: 1) virtual organizations; 2) secret/single key cryptography; 3) public/two key cryptography; 4) application of public key cryptography [key exchange, secure socket layer (SSL), digital signatures, single sign-on, and form signing]; 5) public key certificates; 6) password-based authentication; 7) certificate-based authentication; 8) X.509 certificate standard; 9) certificate authorities (CA), CA hierarchies, CA chains, verification of a certificate chain, management of certificates, and public key infrastructure (PKI); 10) single sign-on; 11) enterprise authentication systems, lightweight directory access protocol (LDAP), pluggable authentication modules (PAM), and Kerberos; 12) authorization versus authentication; 13) grid security infrastructure (GSI), SimpleCA, grid-cert-request, user and host certificates, proxy certificates, and proxy certificate chain of trust; 14) grid-mapfile; 15) grid resource allocation and management; (GRAM) 16) access control based on attributes; 17) attributes in higher education. Some of these topics can be considered to be preparatory and may have already been covered in courses that can be required as prerequisites, such as operating systems. Some topics may be appropriate for advanced students or courses that cover security in-depth. The instructor needs to understand the background of
5
the students in the grid computing course, however, and to cover the preparatory topics if students have not already had them. 2) Topics for Grid Programming: Topics for grid programming have evolved somewhat as the technology and tools have evolved. The topic areas include the following: 1) network architecture and programming; 2) remote method invocation (RMI); 3) Web services and Web services technologies; 4) basic grid programming concepts; 5) advanced grid programming concepts. Topics 1 and 2 are considered to be preparatory. Advanced undergraduate students may have already covered this material. If they have not covered these topics, then the assessment [as described in Section III-B-2)] indicates that covering these topics leads to a much better experience for students in the later, core grid topics. The key subtopics for the preparatory topics in grid programming have been identified, as follows: 1) preparatory topic: network architecture and programming: a. connectionless and connection-oriented networks; b. simple Internet network addressing and architecture (physical, data link, Internet protocol, transmission control protocol, and higher layers); c. client/server programming model; d. stateful versus stateless and iterative versus concurrent servers; e. middleware examples. 2) preparatory topic: remote method invocation (RMI): a. steps of RMI and remote procedure call (RPC); b. marshalling, stubs, and parameters; c. asynchronous RPC and notification; d. directory and registry services; e. distributed objects; f. interface definition and interface languages; g. remote exceptions; h. object request brokers. As the Globus toolkit and other technologies have evolved over several semesters, the subtopics for the core areas in grid programming have evolved as well. These may continue to evolve as new technologies are developed. However, some fundamental subtopics have been identified, as follows: 3) Web services technologies: a. extensible markup language (XML), including tags, elements, attributes, namespaces, and schema; b. simple object access protocol (SOAP); c. Web services hosting environments; d. Web services definition language (WSDL); e. Service oriented architectures (SOA). 4) basic grid programming concepts: a. service interface; b. service implementation; c. deployment parameters; d. compiling and deploying a service; e. writing and executing a simple client. 5) advanced grid programming concepts: a. resource properties; b. multiple resources; c. lifetime management; d. notification in clients and servers.
6
IEEE TRANSACTIONS ON EDUCATION, VOL. 50, NO. 1, FEBRUARY 2007
B. Exercises Homework and a laboratory exercise have been developed for the grid security knowledge area. For each of the subtopics in the grid programming area, a classroom/laboratory exercise has been developed. The exercises have been used in courses at the University of Arkansas and Lewis & Clark College. 1) Exercises for Grid Security: Both a written homework assignment and a laboratory exercise have been developed to explore problems in grid security. The focus of the written homework assignment used at the University of Arkansas is to explore the differences between enterprise security that is provided using the secret key encryption of Kerberos; brokered authentication and authorization that is provided through the federated trust of Shibboleth1; and the PKI-based virtual organization security of the Globus Security Infrastructure. Background is provided through online reading materials available from the website. The developed laboratory exercise used at Lewis & Clark College focuses on public key cryptography and certificates. Background materials came from Schneier [11]. In the laboratory, students first explore the Rivest, Shamir, and Adleman (RSA) algorithm by writing short programs that 1) generate key pairs, 2) encrypt, and 3) decrypt messages. Students then explore encrypting messages with their private key and with the recipient’s public key to achieve specific security requirements. Some students tried to break encrypted messages brute force. Also as a part of the security assignment, students at Arkansas used “grid-cert-request” and e-mail to make a request for a grid certificate. A class system administrator accepted the request via e-mail, used SimpleCA from the Globus toolkit to create the grid certificate, and then responded using e-mail. Students at Lewis & Clark also used accounts on the Teragrid2 to explore certificates (ncsa-cert-request, grid-cert-info), proxy certificates (grid-proxy-init, grid-proxy-destroy), and single sign-on (after securely copying their public key to remote sites). Setup for the RSA programming exercise is minimal since it only requires access to a program development environment. Setup for the SimpleCA was involved and took more than one repeat effort to work successfully. 2) Exercises for Grid Programming: Five exercises were developed in the area of grid programming, corresponding to each of the five topic areas [see Section III-A-2)]. Both the University of Arkansas and Lewis & Clark College courses covered lecture material on the first preparatory topic of network programming using sockets. Setup for this exercise is minimal since the sockets calls are a part of the Java language. At Lewis & Clark College, the book Distributed Computing by Liu [12] provided background material. At both institutions, only a small number of the students had previous experience in writing a socket program. An exercise was developed using socket programming in Java; however, it was only assigned at Lewis & Clark. The exercise is to program a stateful server to play a version of the game “I’m going on a picnic and I’m taking ” in which whenever a client adds one item, the server responds with the list of all 1http://shibboleth.internet2.edu/ 2http://www.teragrid.org/
Fig. 2. Student self-evaluation at Lewis & Clark College (0 = none; 10 = high).
collected items. Students also reviewed concurrency and mutual exclusion. Students were asked to assess their own skill level both before and after each laboratory exercise. The assessment was based on a range of 0 to 10, where 0 meant “none” and 10 meant “high.” Quantitative data is shown for Lewis & Clark College. A small number of students participated in all the assessment at the University of Arkansas, and those results are reported anecdotally. Fig. 2 shows the results of student self-assessment at Lewis & Clark for the Java sockets programming exercise. Prior to doing the exercise, students assessed their skill level to be about 5.8 in the area of Java programming. After the exercise, students assessed their skill level to be about 8.2. A socket program was not assigned at the University of Arkansas and, interestingly, a comment from one of the more capable students in the class after the Java RMI exercise (covered next) was, “The assignment is made more difficult for people who have little or no experience with network communication.” The conclusion is that if students have not previously written a sockets program when they arrive to the Grid Computing course, taking the time to teach network architecture and to assign a sockets exercise is worthwhile. The second exercise covers Java RMI. Both the University of Arkansas and Lewis & Clark College developed programming assignments using Java RMI. At the University of Arkansas, background material came from online sources at the Sun Java website. Based on the online examples, students programmed a four-function RMI server and client. At Lewis & Clark, students programmed a chat room. In the chat room assignment, each client sees all the lines typed by all the other clients. Students learned about stub compilation and the object registry. For the chat room exercise, students learned about callback. Prior to the completion of the exercise, the University of Arkansas students rated their Java RMI skills to be 4.1; one of the students had significant previous experience. The exercise at the University of Arkansas took an average of eight hours. After the exercise, University of Arkansas students rated their skills to be 5.5. At Lewis & Clark College, the students assessed their skill level to be 0.2 prior to the exercise and 6.3 after the exercise (Fig. 2). Although students at the University of Arkansas thought the exercise was reasonable, one conclusion is that the laboratory exercise was too easy. Student comments indicated that there
MACHE AND APON: TEACHING GRID COMPUTING: TOPICS, EXERCISES, AND EXPERIENCES
was too much detail provided in the assignment instructions, and the steps were too spelled out. The Lewis & Clark College chat room exercise had better results. The third and fourth exercises had been derived from earlier work [7]. The exercises are about Web services and basic grid programming. In the third exercise, students build, deploy, and test a Web service that returns the square of its argument. The exercise uses the Apache Axis tools and the Tomcat servlet container. The fourth exercise is to understand the similarities and differences between traditional Web services and stateful grid-enabled services. Students learn to exploit the stateful nature of grid-enabled services. The exercise consists of writing a client–server application that performs banking transactions for a user, such as making a deposit, withdrawal, and providing a balance. At the end, students modify the code by adding a “multiply” method. The results of the student self-assessment of the exercises at Lewis & Clark College are shown in Fig. 2. Students had very little previous experience with Web services (or grid programming) prior to the laboratory assignment. After the third exercise was completed, Lewis & Clark College students rated their skills at 6.8. At the University of Arkansas, students spent an average of five hours on the third exercise. The fourth exercise was assigned as preparation for the fifth exercise at the University of Arkansas and was not graded. Student comments at the University of Arkansas indicated that, even though the general self-assessment of Java RMI skills was not that high, that the previous experience doing the Java exercise helped in being able to do the third and forth exercise. Students also indicated a desire to learn more about how the XML and SOAP messages used in Web services. The fifth exercise asks students to go through the fourth exercise first and then create a new service, MathServiceSD, that adds a GT3 service data element. Background material is from the “The Globus Toolkit 3 Programmer’s Tutorial.” Students spent an average of 20 or more hours on this exercise, but it was the most well-received exercise by students at the University of Arkansas. Prior to the assignment students assessed their skills with grid programming to be 1.6, and after the completion of the exercise, students assessed their skills on grid programming to be 6.7. In contrast, the self-evaluation of grid programming skills at Lewis & Clark College was only 5.6, lower than RMI or Web services (Fig. 2). This evaluation is attributed to the fifth exercise not being completed at Lewis & Clark College because of lack of time. Therefore, at least one additional grid programming exercise is recommended. Following a first grid programming exercise that builds confidence with at least one more elaborate grid programming exercise provides the opportunity for reinforcement and more substantial code writing. IV. EVOLVING AND EXTENDING THE TOPICS AND EXERCISES The first experiment and set of exercises were developed using Globus toolkit version 3. The toolkit and associated software packages have evolved, making infrastructure support for teaching easier, but also requiring some changes to the exercises.
7
Fig. 3. Student self evaluation of GT4 exercise at Arkansas (0 = none; 10 = high).
A. Changes Required When Moving From GT3 to GT4 In January 2004, the Global Grid Forum proposed Web Services Resource Framework (WSRF) as a refactoring and evolution of Open Grid Services Infrastructure (OGSI) [13]. Version 4 of the Globus toolkit (GT4) was released on April 29, 2005. Upgrading the courses was not overly difficult. Changes were only required to the fourth and fifth exercise. The changes for the fourth exercise include 1) starting the container with the “nosec” option, 2) writing WSDL directly, and 3) replacing “void” arguments and return values. A very promising candidate for a fifth exercise is the “sticky note” tutorial [14], which covers lifetime management, notification, index and discovery. This exercise is planned for use in the next iteration of the courses. Other candidates for advanced grid exercises are the “FileBuy” application [4] and large integer factorization [15]. B. Infrastructure and Assessment for GT4 In spring 2006, as a one-week unit in the Concurrent Computing course at the University of Arkansas, the fourth exercise was taught using GT4 and with a different setup. Based on materials from the Globus toolkit developers [14], students installed a GT4 stand-alone container on their individual computers. This installment required some preparatory setup, including the installation of Java, Ant, and Python on Windows computers. The advantages of this approach over sharing one server for all students include the avoidance of Ant build permission conflicts and much better performance than running several containers on the same computer. Two students required significant assistance in setting up the environment on their individual computers, but these students were also performing below average in other areas of the course. Eight undergraduate and three graduate students completed the assessment of the exercise. The students had preliminary knowledge of sockets programming, but concepts such as RMI and Web services were not covered in-depth prior to the grid programming exercise. Fig. 3 shows that there is improvement in several concept areas. Since the course only allowed time for a single grid exercise, the results are consistent with earlier findings. Undergraduates can successfully learn to program grid exercises, and GT4 is not any more difficult than the earlier GT3 material. The improvements in self-evaluation are expected to
8
IEEE TRANSACTIONS ON EDUCATION, VOL. 50, NO. 1, FEBRUARY 2007
be greater when more time is spent on the material in a fullsemester course. C. Additional Topics This paper addresses two of the knowledge areas that compose grid computing. The course at Arkansas also covers topics in the grid usage knowledge area from Fig. 1. A long list of possible tools could be included in course materials, including laboratory activities such as scheduling and job submission with Condor,3 further study of grid resource management, study and use of tools in the Virtual Data Toolkit (VDT),4 and study and use of successful and emerging grids such as the Teragrid and Open Science Grid.5 The grid usage knowledge area may require less programming than developing grid-enabled services. Therefore, materials and exercises for the grid usage knowledge area may be accessible to computational scientists, engineers, and lower division undergraduate computer science students and may help to further broaden the potential workforce for grid computing. D. Related Work The paper [16] by Ramamurthy describes the GridFoRCE project, a two-course sequence aimed at more advanced students. The papers [17] and [18] describe teaching grid computing to more advanced students. The papers [9], [10] by Wilkinson and Holliday describe six assignments for teaching grid computing to advanced undergraduates: Web services, grid services, job submission, job distribution, parallel programming, and using a workflow editor. Whereas, the first two assignments are very similar to the third and fourth exercises here, their third to sixth assignment—covering topics in the “grid usage” and “parallel programming” knowledge areas—would be attractive to students after completing the exercises proposed here, if time is left. (Wilkinson and Holliday report that completing the last step of assignment three was “beyond the skills of most of the students.” As a result, they did “not have enough time for all of the remaining assignments.”) V. CONCLUSION Effective grid computing courses are essential to the training of a workforce that can build the next-generation grid. This paper describes topics, exercises, and experiences of teaching grid computing at a small private liberal arts college (Lewis & Clark College) and a large public Ph.D.-granting research university (the University of Arkansas). Course material in grid computing can be grouped into several knowledge areas. The focus in this paper is on grid programming, i.e., developing grid-enabled services. Experience shows that the technologies involved in sharing resources across the Internet (i.e., grid computing) are very different and have different prerequisite knowledge from the technologies used in high-performance parallel computing 3Condor High Throughput Computing, available [online]: http://www.cs. wisc.edu/condor/ 4http://www.cs.wisc.edu/vdt/ 5Open Science Grid Consortium, available [online]: http://www.opensciencegrid.org/
using a network or cluster of computers (i.e., cluster computing). Cluster computing builds on knowledge of algorithms, and message passing programming in the C or Fortran programming languages. In contrast, grid computing builds on knowledge of the client/server paradigm, network security, Web services, XML, and network programming in the Java programming language. Assessment data shows that with preparatory material and hands-on exercises, undergraduate computer science students can master grid programming. The following recommendations for fellow instructors of grid computing to undergraduate students are presented. 1) Cover (or have as prerequisite) network programming in Java in general, and remote method invocation (RMI) in particular. RMI introduces many important concepts before students are presented with the complexity of Web services and grid programming. Such concepts include stub compilation and interfaces versus implementations. Moreover, students become comfortable managing a large number of files and compilation steps. 2) Cover Web services in general, and XML and WSDL in particular. 3) Cover certificates, at least step by step, and with theoretical background if possible. Typically, one cannot even submit a simple program to the grid without proper certificates. 4) Follow a first, as-simple-as-possible grid programming exercise (that works and builds confidence) with at least one additional grid programming exercise, thus providing the opportunity for reinforcement and more substantial code writing. 5) Do not underestimate the time and effort required locally to set up the required software environment (installation and system scripts). In fall 2004, at the University of Arkansas, a graduate student system administrator with previous Linux experience was hired for ten hours per week to administer the Web services and GT3 environment for most of the semester. GT4 installation seems easier. Alternatives such as the Virtual Data Toolkit are now available for setting up a Globus toolkit environment. Running stand-alone containers on individual student computers is recommended over sharing one server for all students. REFERENCES [1] President’s Information Technology Advisory Committee, “Computational Science: Ensuring America’s Competitiveness,” National Coordination Office for Information Technology Research & Development, Arlington, VA, , 2005 [Online]. Available: http://www.nitrd.gov/pitac/ reports/20050609_computational/computational.pdf [2] I. Foster and C. Kesselman, “Globus: A metacomputing infrastructure toolkit,” Int. J. Supercomp. Appl., vol. 11, no. 2, pp. 115–128, 1997. [3] S. Tuecke, K. Czajkowski, I. Foster, J. Frey, S. Graham, C. Kesselman, T. Maguire, T. Sandholm, P. Vanderbilt, and D. Snelling, Open Grid Services Infrastructure (OGSI) Version 1.0, Global Grid Forum Draft Recommendation, Jun. 27, 2003 [Online]. Available: http://www.globus.org/alliance/publications/papers/Final_OGSI_Specification_V1.0.pdf [4] B. Sotomayor and L. Childers, Globus Toolkit 4: Programming Java Services. San Francisco, CA: Morgan Kaufmann/Elsevier, 2006. [5] A. Apon, CSCE 490/590 Cluster and Grid Computing Fall 2004 Course Home Page [Online]. Available: http://csce.uark.edu/~aapon/courses/ gridcomputingFall2004/
MACHE AND APON: TEACHING GRID COMPUTING: TOPICS, EXERCISES, AND EXPERIENCES
[6] J. Mache, CS 393 Network Programming/Grid Computing Course Home Page [Online]. Available: http://www.lclark.edu/~jmache/gridcomputing/ [7] A. Apon, J. Mache, Y. Yara, and K. Landrus, “Classroom exercises for grid services,” in Proc. Linux Cluster Institute Int. Conf. High Performance Computing, Austin, TX, May 2004, pp. 1–12. [8] A. Apon, J. Mache, R. Buyya, and H. Jin, “Cluster computing in the classroom and integration with computing curricula 2001,” IEEE Trans. Educ., vol. 47, no. 2, pp. 188–195, May 2004. [9] B. Wilkinson, M. Holliday, and C. Ferner, “Experiences in teaching a geographically distributed undergraduate grid computing course,” in Proc. 2nd Int. Workshop Collaborative Learning Applications Grid Technology Grid Education, Cardiff, U.K., 2005, pp. 59–66. [10] M. A. Holliday, B. Wilkinson, J. House, S. Daoud, and C. Ferner, “A geographically-distributed, assignment-structured undergraduate grid computing course,” in Proc. 36th ACM Tech. Symp. Computer Science Education (SIGCSE2005), St. Louis, MO, Feb. 2005, pp. 206–210. [11] B. Schneier, Applied Cryptography. New York: Wiley, 1996. [12] M. L. Liu, Distributed Computing. Reading, MA: Addison-Wesley, 2004. [13] K. Czajkowski, D. Ferguson, I. Foster, J. Frey, S. Graham, T. Maguire, D. Snelling, and S. Tuecke, “From open grid services infrastructure to Web services resource framework: Refactoring and evolution,” Mar. 5, 2004 [Online]. Available: http://www.globus.org/ wsrf/specs/ogsi_to_wsrf_1.0.pdf [14] R. Ananthakrishnan, C. Bacon, L. Childers, B. Clifford, J. Gawor, and J. Insley, “A Globus Alliance tutorial: How to build a service using GT4 [Online]. Available: http://www-unix.globus.org/toolkit/tutorials/ BAS/ [15] V. Silva, Grid Computing for Developers. Boston, MA: Charles River Media/Thomson Delmar Learning, 2006. [16] B. Ramamurthy, “GridFoRCE: A comprehensive resource kit for teaching grid computing,” IEEE Trans. Education, vol. 50, no. 1, pp. 10–16, Feb. 2007.
9
[17] E. Elmroth, P. Gardfjdll, and J. Tordsson, “An advanced grid computing course for application and infrastructure developers,” in Proc. 2nd Int. Workshop Collaborative Learning Applications of Grid Technology Grid Education, Cardiff, U.K., 2005, pp. 43–50. [18] R. O. Sinnott, A. J. Stell, and J. Watt, “Experiences in teaching grid computing to advanced level students,” in Proc. 2nd Int. Workshop Collaborative Learning Applications of Grid Technology Grid Education, Cardiff, U.K., 2005, pp. 51–58. Jens Mache received the Vordiplom degree from Universitaet Karlsruhe, Germany; the M.S. degree from Southern Oregon University, Ashland; and the Ph.D. degree from the University of Oregon, Eugene, in 1999, all in computer science. Currently, he is an Associate Professor of computer science at Lewis & Clark College, Portland, OR. His research fields are parallel and distributed systems and networking. His interests include cluster and grid computing, sensor networks, ubiquitous computing, network security, peer-to-peer systems, Web services, e-business, parallel input/output, scheduling, resource management, and performance evaluation. His work is supported by the National Science Foundation, the W. M. Keck Foundation, and the John S. Rogers Program. Amy Apon received the B.S.Ed. degree in mathematics education, the M.A. degree in mathematics, the M.S. degree in computer science from the University of Missouri–Columbia, and the Ph.D. degree in computer science from Vanderbilt University, Nashville, TN, in 1994. Currently, she is an Associate Professor in the Department of Computer Science and Computer Engineering at the University of Arkansas, Fayetteville. She is the Principle Investigator on an MRI grant from the National Science foundation and has been the Principle Investigator on other grants from the National Science Foundation (NSF), other government funding agencies, and industry. Her current research projects include an NSF-funded project in the areas of middleware for cluster computing and teaching grid computing to undergraduate computer science students. She has a currently funded project from Acxiom Corporation in the area of performance modeling and capacity planning of grid-based computer systems.
