Programming Paradigms via Mathematica: Preface

    Programming Paradigms via Mathematica introduces both the major concepts of introductory programming as well as the various programming styles, or paradigms, found in current programming languages. We consider programming in a variety of contexts and at a variety of levels---from short questions to large group projects---in order to present a broad picture of programming as a versatile tool. The text provides a solid foundation for later courses, including Data Structures, Algorithms, and Comparative Programming Languages, while at the same time leading toward courses which develop the skills of the programmer in a particular programming language, be it C++ or Pascal, list-based, functional, object-oriented or procedural. The language Mathematica is the means to these ends, providing a context for the introduction of practical techniques while avoiding the necessity of devoting the first half of an introductory course in computer science to the specific details of a specialized computer language. This text begins with powerful intrinsic (pre-defined) functions and quickly progresses to significant list-based programming. Interesting problems employ new concepts and technical details as they are developed. In this spirit, we do not emphasize the specialized techniques of a Mathematica programmer but instead highlight within Mathematica the various programming styles of a list-based, procedural, or object-oriented programming environment. Our treatment enables an understanding of, and easy adaptation to, the approach of such a specialized programmer in a wide array of languages, with Mathematica and C++ being conscious instances.

    Our text is appropriate for a beginning course in computer programming, without prerequisites. The text covers much of what is known as CS1 in the current curriculum standards for computer science. It is to be expected that the programming experience of students for this course will vary from absolutely none to considerable practice in some language, though probably other than Mathematica. Students should be comfortable with mathematics and computer usage, to the extent that basic ideas from each are introduced throughout the course; a good background in high school mathematics coupled with experience using a mouse and keyboard with computer software is sufficient. Any student who has completed a CS1 course---regardless of language---or who has extensive algorithmic programming experience should step beyond this book to a course with

narrower goals.

    One example of our approach is found in a central theme of the text, the juxtaposition of three alternative approaches to repetition: list-based operations, recursion, and iterative loops. Each is important in modern programming in its own right, and our text considers each in detail. The three methods are first compared as solutions to factorial programming at the beginning of Section 5. List-based programming is then developed first, in Chapter II. Functions are applied to lists in many different ways, represented by several higher-order functions. In Chapter V we emphasize recursion as a more universal technique to accomplish repetition, providing many problems involving lists in order to encourage comparisons with list-based programming. Finally, in Chapter VI we discuss iteration in the classic context of procedural programming and explore the advantages and disadvantages of such a style. Implementing higher-order list functions from Chapter II as procedural functions encourages still more comparison while providing excellent exercises in the understanding of basic algorithms.

    In exploring repetition in these ways, the advantages to instructor and student of using Mathematica are brought into clear focus. By considering list-based programming first, we can avoid the crutch of understanding iteration only in procedural programming. And since list manipulation is natural to Mathematica, we can quickly enable students to accomplish significant tasks with a small amount of thought-provoking code. Even further, in list-based programming we are able to encourage students to think of functions and higher-order functions separately, using for instance the grammatical interpretation in which functions are verbs and higher-order functions adverbs, as emphasized in Ken Iverson's language J. When we reach the recursive approach, Mathematica provides advantages over traditional programming languages, easily allowing multiple definitions for the same function with different arguments: the general case ``doItTo[n\_]'' can reduce to the base case ``doItTo[0]''. In this way we easily introduce the concept of pattern-matching in symbolic programming. Finally, in the procedural approach to repetition, we find that many of the syntactic structures in Mathematica are much like C, paving the road to future programming in C or C++.

    In having students avoid the syntactical and structural considerations of a specialized programming

    language---as well as the time such considerations require---we allow time to consider a wide variety of important programming concepts. Modular programming, with local and global scope considerations, is placed front-and-center in Chapter III. Bottom-up and top-down analysis, string type, and ASCII codes are all covered near the beginning of the text; various conditional execution structures, call-by-reference, and call-by-value nearer the end. At several places we consider the tradeoffs between time and space in order to lay a framework for algorithmic analysis in later courses. In particular, compilation is one minor theme of the course, reaching full expression in one of the later sections. Pascal-style records have an analogy in the structured patterns of Section 12, and a programming style similar to pure functional programming is enabled by a discussion of anonymous functions. We note that some of the code we provide mimics rather than fully implements certain topics; for instance, we discuss call-by-value and call-by-reference and ``interpret'' Mathematica constructs in this fashion, ignoring the fact that Mathematica is more precisely a large rewriting engine.

    A course that fulfills the intention of this text should cover most of each section through Section 17 or 18 on iterative programming. If time is available, the syllabus could complete additional sections through Section 20 on function calls. At this point, three distinctly different ways to continue in the text present themselves: (1) The remainder of Chapter VII covers more valuable general programming topics such as object-oriented programming and file manipulation; (2) Chapter VIII bridges the gap to other languages by lessons in reading actual code from these languages; finally, (3) Chapter IX covers special topics for the Mathematica user. In particular, graphics (and even animation) is a fun reward to students who have completed the heart of the course. While there are many texts on Mathematica that seek to impress students with gee-whiz-bang graphics at the beginning, we find that student exploration at the end is more appropriate, as well as more informative. For some audiences, the section on substitution and rewrite rules fills a gap in the understanding and use of Mathematica-specific techniques.

    Our text ends with a summary section, which we find is a valuable way to reflect on the many alternative approaches that have been developed and how they fit into several different paradigms or modes of programming, including functional, procedural, array-oriented, logic, symbolic, and

    object-oriented. Using it as a point of reference, we are able to stress to students that most languages tend to encourage one paradigm over another; Mathematica itself was designed with ideas from sources as diverse as the procedural language C and the array-oriented (list-based, in our terminology) language APL. Once these various paradigms are explored, we return to a brief consideration of Mathematica, ultimately an example of the less common paradigm of symbolic programming. One useful way to broaden the scope of the course further is to consider how one might apply list-based concepts to parallel programming, treating the ways in which algorithms might be implemented more efficiently depending on the array of computing processors available.

Rich Neidinger

John Swallow

Todd Will

Davidson College

Davidson, North Carolina