To produce students -- both IT professionals new to this area as well as college and university students -- who understand J2EE architecture, can design J2EE layered applications, and implement those designs using Studio, WebSphere, and DB2. More specifically, our overall goal is to help students get over the initial learning curve more quickly so that they can move on to more extensive design considerations and a more extensive understanding of J2EE technologies and tools.
Context. The issues we are addressing apply to individuals learning J2EE and related tools, such as WebSphere Studio, in any context, ranging from intensive time-compressed seminars to semester-long university courses. These issues apply to IT professionals -- both within IBM and in outside IT industry -- as well as college and university students. In the interest of brevity, we will describe our ideas and our work in the context of a university setting (UNC), but they should be read in the broader context.
We offer a three-course sequence in Web-Based systems. The third course, numbered Comp 119, is concerned with Enterprise Systems, in general, and J2EE, in particular. We make extensive use of Studio, WebSphere, and DB2 in that course. A key part of this course is a student project where teams of 3 or 4 build a non-trivial J2EE application of their own design. However, it currently takes students so long to learn the J2EE architecture and technology they need in order to do reasonable designs, they don't have sufficient time to implement those designs satisfactorily.
To be more specific: in order to design a J2EE layered system, students must first understand the J2EE architecture and the various constructs that it provides, such as Struts, Session and Entity EJBs, Container-Managed Transactions, Container-Managed Persistence, EJB-QL, Container-Managed Relations, DataSources, DB2 connection and interactions, etc. They must also learn how to use necessary tools, such as WebSphere Studio. This learning process is best accomplished through a combination of reading instructional materials (e.g., Brown, et. al, Enterprise Java Programming with IBM WebSphere), reading J2EE documentation, and building a simple, exercise-level end-to-end system that facilitates learning both tools and concepts.
In a university setting, it currently takes students some 6 to 8 weeks to accomplish this preliminary task (similar proportions of time, or worse, apply to other contexts, such as intensive workshops). Once students have this understanding and these skills, they can move on to design methods, project design, and project implementation. But, trying to do so before, means they are trying to do something they literally don't understand. The problem, of course, is that the time it takes to gain this basic, prerequisite knowledge does not leave sufficient time to gain the level of knowledge they need for professional practice.
Thus, before students can design a project that will drive their learning, they must first learn a large portion of it as a prerequisite -- a catch 22 situation.
Our project includes three lines of work.
First, we will build code generators that will do most of the work involved in implementing simple end-to-end applications, thereby accelerating development of preliminary, exercise-level systems. Simple applications that rely on a DBMS for persistence are likely to be based on standard CRUDS methods (Create, Retrieve, Update, Delete, and Search). Thus, for example, if the design calls for registration, login, and a simple application such as an addressbook, a catalog of photographs, a record collection, etc., the system is likely to include functions for creating, retrieving, deleting, etc., various types of data stored in separate tables. That is, CRUDS methods for different data object types. Of course, the CRUDS method set may be extended for specific applications or to provide additional function. We are developing superclasses to support CRUDS methods for the interior layers of a seven-layer J2EE architecture. Doing so is non-trivial because of different constraints that exist for the various levels -- e.g., Session EJB classes can't be abstract -- and, thus, would not be apparent to someone new to this area. Our code generators will exploit these superclasses.
Second, we will support a sequence of architectural layers that are based on more familiar architectural concepts. Currently, layers are tied to J2EE technologies, such as Struts Actions, Session EJBs, Entity Beans, and DB Mapping. However, design patterns and best practices have greatly constrained the use of particular layers for particular purposes. For example, Session EJBs are normally kept very "thin," largely providing access control and transaction support. Similarly, the semantic or business logic is concentrated in a "mapping" layer between Session and Entity Beans. Thus, we can speak of View, Control, Access, Transaction, Business, and Persistence as an alternative. A conceptual model expressed in terms such as the latter will be more apparent to students and will enable them to move on to building simple end-to-end applications more quickly. We will build and test such a model.
Third, we will pull the first two parts of the project together in a set of Eclipse tools/plugins. Tools will include wizards, dialogs, automatic code generators, and graphical editors, supporting both design and implementation. The generated applications will be based on the CRUDS superclasses, described above, and will allow the user to select from the default methods as well as add additional methods that must be fleshed out. The design part of the project has obvious relation to UML concepts, and we will attempt to integrate our tools with UML tools.
We will also develop on-line course materials to support learning and use, which we will make freely available.
First, building the collection of design tools and code generation components for the Eclipse and Studio environments will require some work at the level of advanced development, but other aspects will require research. We will use conventional tools, such as wizards and dialogues, but we will also develop novel graphical tools, including visual design tools that solicit declarative knowledge. The code generation aspects of our project, including developing superclasses for some J2EE layers, will also require innovation.
Second, we briefly sketched an alternative conceptual model for system design that emphasizes functional layers (e.g., view | control | domain model | access | transactions | etc. ). One aspect of our research is to extend this model to account for other design factors in a way that is both understandable and useful. For example, a second dimension is object decomposition within a layer. A third considers how the same object can be conceived in different ways by different individuals. For example, a customer or user has one way of thinking of an object ( e.g., an addressbook), but that same object might be thought of as a Java Object, a collection of DataBeans, and as a table in a database by individuals responsible for system design and/or implementation. Thus, we are attempting to build a conceptual model that will integrate multiple design dimensions, including functional layering, object decomposition (within a layer), and a sequence of conceptual schemas used by different types of users for understanding design objects.
Third, we will test both our conceptual model and our tools in the classroom. We will determine whether they help students learn J2EE more quickly and whether they are able to design projects at an earlier stage. This research will be based on observation and feedback, not formal experiments, but we will systematically collect data and we will consolidate results over multiple groups of students.
Thus, we expect to learn a great deal about how individuals new to this area learn to design and build J2EE systems as well as what kinds of tools and resources can help them gain this knowledge more quickly and efficiently.
John B. Smith,
Professor
Diane Pozefsky,
Research Professor and Scientist,
Formerly, IBM Fellow
Kyle Brown,
IBM Senior Technical Staff Member