*matrix*differs in each package—in Maple, it's a matrix; in Mathematica, it's a list; and in Matlab, it's a number. These treatments also reflect each package's underlying character. Maple, for example, uses different type names to distinguish scalars, vectors, and matrices. It also uses conventional mathematical notation in its output, revealing the value it places on mathematical convention in the naming and visual appearance of objects and processes. Matlab has a more pragmatic sense of what's useful by favoring computational conciseness. It treats every datum as a matrix, for example, but of different orders for scalars, vectors, and higher-order tensors. Mathematica reveals something of its underlying sophisticated computation-theoretic values by favoring abstract structures—it treats a matrix as a list of embedded lists, for example.

*procedures, objects,*and so on) are a common way to limit the scope of variables and thus the conflicts that can arise from using competing variable names. They're also useful for grouping and associating command sequences. Figure 8 illustrates how "procedural" methods work in each of the three packages.

*x*and

*y*and assign them (initial) values. Note that Output[1] and Output[2], returned after entering the Module definition, express symbolic objects—z1 and z2—because they haven't been evaluated yet. Once these formally symbolic objects are evaluated, as in Input[3], the results are the values of seriz and parallelz expressed in Output[4] and Output[5].

*x*and

*y*as local.

**Maple.**The Maple Worksheet—Maple's standard interactive interface—is a generalized type of GUI that allows the entry and execution of commands and simple code clusters within cells in the Worksheet window. Specialized Maple GUIs created as code objects are called Maplets; the Maplet development environment is implemented as a set of specialized commands in a separate subpackage that is integrated into the standard Maple code development environment. Maple supports interoperability for C, Java, and Visual Basic. OpenMaple is an API into Maple that lets users write programs in C (and thus C++), Java, and VisualBasic (VB) and then call Maple routines from within those programs. Maple also has built-in functionality to automatically generate optimized code in C, Fortran, Java, Visual Basic, and Matlab (M-code), given a Maple equation or a Maple program.

**Mathematica.**The Mathematica Notebook—Mathematica's standard interactive interface—is also a type of GUI. Predictably, Mathematica's debugging facilities are elaborate and exotic. The package doesn't have a debugger per se; rather, it has an extensive set of Trace commands integrated into the system that let you identify details in the execution sequence of commands. Mathematica's GUI development environment is a toolkit based on Java classes—in particular, on the extensive class libraries of Java GUIs. The GUIKit provides high-level expression syntax for defining common user interfaces, obviating the need for the developer to write Java code. Mathematica comes with MathLink, J/Link, and .NET/Link, all of which let users call to and from code written in C/C++, Java, and .NET languages. Mathematica also comes with a built-in database link.

**Matlab.**Matlab's standard interactive interface is a window with a partition for processing command-line input. The vehicle for complete application units is either an M-file, consisting of Matlab commands, or a compiled version of an M-file created for a platform-specific target. The Matlab programming language's architecture is such that only relatively simple elements are executable in a single code block within a command-line structure. Creating and testing most computational codes thus involve two separate operations: creating M-file text, and then executing them to test and debug. Matlab provides both a set of debugging commands that can be embedded in M-code and a graphical debugger for fully interactive debugging. Most program developers using standard languages; their code development environments will find the Matlab environment to be familiar. Matlab also provides a development environment for creating specialized GUI's (GUIDE). Moreover, it has a definition for interfacing to external routines written in other languages, including Java, C, and Fortran, as well as to a variety of data objects and servers that communicate via the Component Object Model (COM). Calling C, C++, and Fortran via wrapper functions, VB via COM, and Java classes from Matlab is fully supported and documented. C++ is partially supported, but calling Matlab from C, C++, and Fortran via the engine library and VB via COM is fully supported. Calling of Matlab from Java and C# is partially supported.

The importance of program code management and debugging facilities is directly proportional to the complexity and number of instructional products that the developer intends to create. Among student users, these facilities are most important for computational programming, less important for simulations, and least important for tutorial materials.

**Maple.**Maple has extensive style facilities that couple text to functional and structural elements. It assigns separate, definable styles to input, text output, graphical outputs, and expository paragraphs. If you select a style from a pull-down menu according to function—for instance, "Maple Input"—then that textual style is applied to the subsequent input. Moreover, the kernel treats that input as Maple language. If you select text style, the subsequent input appears (and is treated by the kernel) as expository text. Maple also provides a selection of tools for data and command formatting on palettes in the system development window. You can select alternatively among expression, symbol, matrix, and vector renditions of these palettes; using them can considerably reduce the typing burden for both developer and user in the Worksheet environment. On the output side, as we pointed out earlier, Maple emphasizes the appearance of standard mathematics.

**Mathematica.**Mathematica's hierarchically structured system of input cells has functional implications for code execution. The kernel distinguishes between Mathematica language and expository text via the key used to terminate an input: the Return key indicates expository text and the Enter key, Mathematica language in the input stream. On the output side, as we've mentioned, Mathematica is the least constrained among the three by mathematical convention. With respect to the appearance of text however, it has a system of predefined styles applied via pull-down menus. Moreover, Mathematica provides an elaborate range of "appearance environments" that anticipate what size and layout choices best satisfy certain operational modes, such as "working," "slide show," and so on. For the developer as well as the user, Mathematica provides customizable tool palettes to implement formatting, simplify command entry, and reduce the typing burden. Mathematica also provides its own specialized wizard functions, among them a set specifically for authoring: MakeProject, MakeIndex, and MakeContents.

**Matlab.**Matlab places its formatting commands for text in pull-down menus. It permits the author to set style properties for target objects, but if those objects will contain considerable amounts of instructional text rather than, say, labels or legends, the developer must generate the formatting by coding it or creating it exogenously (for example, in a word processor) and importing it. This limited capability is consistent with what programming environments require—elaborate formatting isn't important here. Although importing files into an application is quite easy in Matlab, it makes the preparation and use of considerable amounts of text with sophisticated formatting a comparatively awkward process.

Text formatting is very important for creating tutorial material, less important for simulations, and relatively unimportant for computational programming. Less obvious is the importance of functional formatting—using formatting to distinguish between input and output, to link typography with logical organization, to serve one or another disciplinary custom, and so on. The formatting choices the packages offer seem to match up with their user bases: Maple has a traditional following in the mathematics education community, Matlab in the engineering education community, and Mathematica in the physical science education community. These have as much to do with history as with computational capability, yet the packages' formatting capabilities seem to favor the needs of their communities of educational developers.

*all*science and engineering students should have experience in using modern computational tools. This is hardly a radical conclusion. As we've pointed out, undergraduate engineering program accreditation already requires this. Even so, our survey has given us the impression that in undergraduate sciences at least, such a commitment is "more often honored in the breach." But what kinds of computational experiences are adequate and appropriate for all undergraduates? In addressing this question, it might be useful to refer back to the questions we used to frame the first installment of this series:

• To what extent do these tool packages qualify as modern engineering tools?

• What kinds of computational experiences with them are appropriate for undergraduate students?

• What are some major educational goals for science and engineering undergraduates?

• How are specific computing tasks related to those goals?

• How does each of the three productivity packages realize the required computations?

• How well do these tool packages serve for materials-development work that faculty will likely perform alone?

• How efficient are they when fast response times are required for modifications?

• How expensive are they to purchase and, equally important, maintain?

*n*×

*m*) and (

*m*×

*n*) matrices. Many shortcuts in its command vocabulary and the implicit assumptions it uses in interpreting input are common to mathematical analyses.

*CiSE*Web site: www.computer.org/cise.

**Norman Chonacky**, most recently a senior research scientist in environmental engineering at Columbia, is currently a research fellow in the Center for UN Studies at Yale. Chonacky received a PhD in physics from the University of Wisconsin, Madison. He is a member of the American Association of Physics Teachers (AAPT), the American Physical Society (APS), the IEEE Computer Society, the American Society for Engineering Education (ASEE), and the American Association for the Advancement of Science (AAAS). Contact him at cise-editor@aip.org.

**David Winch**is emeritus professor of physics at Kalamazoo College. His research interests are focused on educational technologies. Winch received a PhD in physics from Clarkson University. He is coauthor of

*Physics: Cinema Classics*(ZTEK, videodisc/CD 1993, DVD/CD 2004). Contact him at winch@taosnet.com.

| |||