Outline of Class 1: Introduction

About This Class

• CS 223 is a course in Software Design.
• Of course, that means a lot of different things to different people.
  • It also means almost nothing to some people.
• One of the best definitions comes from the Association for Software Design (although I stole it from the Winograd book)

  Software design sits at the crossroads of all the computer disciplines: hardware and software engineering, programming, human factors research, ergonomics. It is the study of the intersection of human, machine, and the various interfaces - physical, sensory, psychological - that connect them.

• We'll probably orient ourselves a little bit more towards the software engineering and programming aspects, but will certainly consider these other issues.
• From a practical perspective, this course is intended to make you a better programmer. How? By exposing you to a number of ideas, techniques, and tools.
  • You'll be trying to approach many problems from an object-oriented perspective, rather than a procedural perspective. (I'll admit that I still think procedurally, so we may work on this together.)
  • You'll be following guidelines from software engineering on the use of an engineering notebook and the application of that notebook to estimates.
  • You'll be working on a number of small programs intended to get you to think about the problem solving process.
  • You will investigate a number of case studies of the software engineering process: how large projects succeeded or failed.
  • You will learn some traditional Unix-based tools for software management, including rcs and make.
  • You will gain experience working in a group and dividing responsibilities within that group.
  • You will read about, and perhaps even perform a study on, human factors in computing systems.

Grounding Ourselves

• Before we delve too far into these issues, we should ground ourselves somewhat by asking ourselves a few questions (and I'll be asking these of the class).
  • What is Computer Science?
  • What is Computer Programming?
  • How are they similar? How are they different?
  • What is an algorithm?
  • What is a computer program?
• We also want to ask ourselves some practical questions.
  • What programming languages do we know?
  • What CS or programming concepts are we least comfortable with?
  • How comfortable are we with the workstations and Unix?
• Finally, I'd like you to reflect on the course (and you'll be doing this again on the introductory survey).
  • Why are you taking this course?
  • What do you expect to get out of this class?

Adminstrative Issues

• Okay, we also need to go over some administrative issues. Most of these are covered in the accompanying web documents.
• The course front door can be found at URL http://www.math.grin.edu/~rebelsky/Courses/223/97F/index.html
• There is some basic information and a list of books for the course.
• You can find more information in the extensive course guide.
• You can get some sense of what we'll be covering from the syllabus.
• Some time over the next few days, you should fill out the introductory survey.
• You also have an assignment to complete for next Wednesday.

Introduction to Java

• Java is an object-oriented language developed by Sun Microsystems.
  • It was ostensibly developed for developing large programs.
  • Often, these programs were to run on autonomous systems, like toasters.
  • With the popularization of the World-Wide Web, it has also become popular as a language for creating transportable applications.
• Java looks a lot like C and C++, two popular languages. It has many differences from the two.
  • It is object-oriented, unlike C; and has a different view of object-orientation than C++.
  • It provides automatic memory management (yay!).
  • We'll see some others as time goes on (some even in the next topic).
• Sun says that Java is "a simple, object-oriented, distributed, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, and dynamic language."
  • Simple. Compared to many modern languages, there is not too much to the core of Java. However, a great deal of functionality exists in the standard libraries, and you will eventually need to learn those libraries.
  • Object-oriented. Java focusses on the creation of classes and objects. Every Java program begins with a central class or object.
  • Distributed. Java permits you to place different portions of a program on different servers, to segment processing between servers, and so on and so forth.
  • Interpreted. Although a compiler translates Java code to another format (byte codes), an interpreter is required to execute or further translate the byte codes.
  • Robust. Java provides a number of facilities for ensuring that things don't go wrong or that, when they do, the programmer provides for problems.
  • Secure. The Java interpreter will often limit what a program can do (from accessing the file system to reading memory outside of a valid range). We often say that Java gives each program a sandbox to play in.
  • Architecture neutral. A Java program will run identically (except for speed) on every platform. Unlike most languages, which can have a different implementation on every platform, Java has specific requirements for essentially every part of the language (from the amount of storage used for various data types to the algorithms used for numeric computation).
  • Portable. See the sections above on architecture neutral and distributed.
  • Multithreaded. A program can have separate threads of computation, and it is relatively easy to manage those threads.
  • Dynamic. New objects can easily be created, and new classes can be loaded as the program runs.

Preparing to work with Java

• While you are free to do your Java development on any machine that you deem appropriate, while you're in class you'll need to work on the departmental MathLAN. That's also where I'll be doing my work.
• There are two versions of Java installed on the MathLAN. We'll be using the beta version of the Java 1.1 compiler, as that matches the one in our textbooks.
• You will need to configure your account to use Java. In particular, you will need to make two basic changes to your .cshrc file.
  • Somewhere in your .cshrc add the line
    set path = (/usr/local/java/bin ${path})
    This tells your shell to look in the new Java bin for the appropriate programs.
  • Somewhere in your .cshrc add the line
    setenv CLASSPATH ".:/u2/rebelsky/Courses/152/structure.zip"
    This tells Java to use that file for some classes. (Yes, even if you're not in 152, you may want to use those classes.)
  • It's best to log out and log in again to make sure those changes take (or, minimally, to open a new shell), but you can also type source ~/.cshrc to get those changes accepted in the same session.
• To translate a .java file to a .class file, you use javac, the Java compiler.
• To interpret a .class file, you use java, the Java interpreter.

Your first Java program

• What do you need to know to write a Java program?
  • A Java "program" begins with a particular class (the class that you tell the Java interpreter to execute).
  • That class must have a main routine, which is the routine that the interpreter executes.
• Here is a simple Java program to print "Hello World!" on the screen.

  public class HelloWorld {
    public static void main(String[] args) {
      System.out.println("Hello World!");
    } // main
  } // HelloWorld
  

• Save that program as HelloWorld.java.
• To compile the program, type
  javac HelloWorld.java
• To execute the program, type
  java HelloWorld
• Let's try to deconstruct our program
  • The first public says that our class is publically accessible. Later, we'll see why and how you might want to have private classes.
  • The class tells the Java compiler that we're defining a class.
  • The HelloWorld names the class. In general, the name of your class should correspond to the name of the file that defines the class (and you should only define one class per file).
  • The left brace begins the definition of the class.
  • Skipping ahead to the end, the final right brace ends the definition of the class.
  • The two slashes begin a one-line comment. I make it a practice to comment every (or nearly every) right brace.
  • Backing up, the second public says that our main function is publically accessible.
  • The static says that the function belongs to the class as a whole, and need not be associated with a particular object of the class.
  • The void says that the function has no return value.
  • The main names the function.
  • The stuff in parentheses are the parameters to the function. Every main function takes the same set of parameters, even if it may not use them.
    • The String[] indicates that the parameter is an array/vector of strings.
    • The args names that parameter.
  • The left brace begins the function.
  • The right brace ends the function.
  • The body of the function says to call the println method of the out object provided by the System class, using the string Hello World! as a parameter.
• Ignoring the class, in Scheme this would be written something like

  (define (main args) (write "Hello World!"))