New version page

PACISE 2010 Dale Parson Final

Upgrade to remove ads

This preview shows page 1-2-3 out of 10 pages.

Save
View Full Document
Premium Document
Do you want full access? Go Premium and unlock all 10 pages.
Access to all documents
Download any document
Ad free experience
Premium Document
Do you want full access? Go Premium and unlock all 10 pages.
Access to all documents
Download any document
Ad free experience
Premium Document
Do you want full access? Go Premium and unlock all 10 pages.
Access to all documents
Download any document
Ad free experience

Upgrade to remove ads
Unformatted text preview:

APPRENTICESHIP IN UNDERGRADUATE JAVA PROGRAMMING Dale E. Parson Kutztown University of Pennsylvania, Department of Computer Science [email protected] ABSTRACT Even the best textbooks for Java programming have one substantial deficiency. They use small, isolated programming examples and throw-away lab exercises that do almost nothing to convey the situated application of object-oriented language constructs. An alternative approach is to embed Java programming assignments as encapsulated modules in an extensible application framework built up across semesters and several courses, with instructors serving as lead analysts and architects. Taking its cues from professional software engineering practices, as well as the educational practices of situated learning, cognitive apprenticeships and microworlds, this approach has the fundamental goal of embedding the introduction to Java programming in a realistic software and social environment from which students can learn via reading, observation, incremental exploration, interaction and deployment of their creations, in addition to the writing and testing of code. Students get a feeling for the categories of work and types of problems they will encounter in supporting and extending professional software frameworks created initially by others. They learn to apply object-oriented constructs by the end of a semester, and they may perform more sophisticated engineering on their software framework in subsequent courses. This paper reports the successful results and pitfalls of applying this approach. KEYWORDS cognitive apprenticeship, Java, microworld, situated learning 1. Introduction Object-oriented software engineers spend their working lives exploring, extending and repairing frameworks that they did not create. Entrée into a project often comes with a sense of being overwhelmed by the volume of information that the software engineer feels compelled to absorb. New entities and relationships are everywhere. Some are well-structured and documented, but many are not. There are many skills gained by experience that keep an engineer from becoming overwhelmed. Cognizance of the structural differences between airtight inter-module boundaries on the one hand and amorphous inter-module coupling on the other helps an engineer restrict the scope of exploration to only those modules with potential impact on the tasks at hand. The ability to discern structure and design intent while reading other people’s code is a critical skill. Another is the ability to distill specifications into concise documentation for annotating interfaces and system components. Communication with engineers and other players is perhaps the most important skill because, when employed artfully, it can open paths to the other important skills. A novice software engineer cannot cultivate these skills working in isolation on small projects. It is necessary to embed one’s attention in a growing, evolving software system that requires reading and comprehension in order to grow these skills. This paper summarizes an ongoing approach for teaching Java programming to undergraduate students at Kutztown University in the CSC 243, Java Programming course. The approach is one of analyzing and extending a software framework that persists and grows across semesters. The framework serves as a product that the instructor and students extend. The author initiated this approach to teaching Java programming beginning in the fall 2008 semester for two reasons. First, the author had just entered academia as a full-time assistant professor after working for twenty years as a professional software engineer, including an eight year stint as a senior software architect in a team that designed, built and maintained a user-extensible software tools framework for simulating, debugging, and monitoring embedded communication systems [1-5]. The author had mentored numerous junior software engineers in the practices of object-oriented software engineering of systems implemented using the Unified Modeling Language (UML) [6], C++ and Java, as well as mentoring numerous graduate student interns from Lehigh University at Bell Laboratories in Allentown. The author saw an opportunity to apply industrial mentoring techniques to teaching Java programming at Kutztown University. The second motivation for initiating this approach was the paucity of realistic examples of Java software systems among the lab exercises in textbooks. The conventional approach taken by introductory Java textbooks [7-15] is that of teaching students the basic mechanics of the programming language using small, concise examples that illustrate the topics at hand, but that do not embody problems and opportunities found in object-oriented systems. The examples illustrate basic language mechanics, but by their nature they cannot inform the students about appropriate contexts in which to apply these mechanics. Some mechanisms of an object-oriented language such as package partitioning, interface and implementation inheritance, and generic class design cannot be realistically illustrated using small, concise examples. These system-level language constructs span multiple Java classes and packages. They require embedding within substantialexample bodies of code before their utility becomes clear. To understand the utility and correct application of the object-oriented features of a language, it is necessary to see them employed and to work with them in situ. Students learn about object-oriented constructs by watching them interact in their intended environment, and by interacting with them there. Novices do not have the experience to employ out-of-the-book abstractions. It is precisely this lack of experience that the present approach looks to address. Rather than teach object-oriented abstractions as concepts, this approach seeks to make them concrete experiences that are acquired incrementally in the process of performing small, concise increments of work inside a larger, object-oriented environment. As with conventional textbook code, student examples


Download PACISE 2010 Dale Parson Final
Our administrator received your request to download this document. We will send you the file to your email shortly.
Loading Unlocking...
Login

Join to view PACISE 2010 Dale Parson Final and access 3M+ class-specific study document.

or
We will never post anything without your permission.
Don't have an account?
Sign Up

Join to view PACISE 2010 Dale Parson Final 2 2 and access 3M+ class-specific study document.

or

By creating an account you agree to our Privacy Policy and Terms Of Use

Already a member?