CIS 67: Program Design and Abstraction Class Log Fall 2005

• 12/06/05 - Class on 12/06
  • The CIS67 final final exam is on Friday December 16 from 2 to 4 pm in Barton BB107(not Barton BB102).
  • Returned and discussed eleventh 5-minute test
  • A handout you will have available at the exam.
  • The complete definition of Java is available online in a wonderful but difficult book The Java Language Specification.
  • The Java Developers Almanac: examples of use of Java constructs and API
  • The importance of remembering: as you review the course material, try to remember examples of use for each construct or feature that you study. Build in your head a library of programming idioms, standard ways of doing usual things. For example, how to read from keyboard, how to read from a file, how to deal with exceptions, how to find the tokens in a string, how to insert into a sorted sequence, how to use arrays, single or multidimensional. Interfaces make more sense if you remember Comparable, and abstract classes if you remember the Employee hierarchy.
  • Counting the lines, words, and characters in a file.
  • Beware of immutable values. Even though two immutable objects (say Integer, or say String) may contain the same value, they may not be '=='. Here is an example.
  • Review: this and super
  • Review: Scope of identifiers. Visibility. Allocation on the stack vs. dynamic allocation. Parameter passing.
  • Remember that object references are references. Thus different variables may denote the same object and "==" compares the references, not the objects being referenced.
  • The type of a reference (static type) vs the type of the referenced object (dynamic type) = Dynamic binding = Lazy binding.
  • Review: Developing a Java program - phases in software development; using stubs and drivers; careful testing; programming by contract to minimize dependencies between programming units. How Java features facilitate program development: packages, classes, inheritance.
  • Review: Arrays are objecs. There are no multidimentional arrays, instead we have arrays of arrays, which can be jagged.
  • We now know how to write simple programs. At a more advanced level, we have started to understand inheritance and polymorphism.

• 12/01/05 - Class on 12/01
  • Programming by Contract.
  • Syntactic errors, semantic errors, logical errors, runtime errors.
  • Concrete classes, the classes we have known and loved for which we can define constructors to create instances. Abstract classes: to start a hierarchy of related classes.
  • Interfaces .. a kind of multiple inheritance
  • Example of interface, the GeometricShape interface, and how Triangle, Rectangle, and Circle implement it. Seen how this simplifies the computation of the sum of the areas of all the geometric forms in a collection.
  • Remember the interfaces Comparable and Cloneable.
  • Single vs multiple inheritance.
  • Overriding vs Overloading
  • Access modifiers when overriding a method of a superclass: it must not be more restrictive.
  • The "final" attribute in the case of variables, of methods, and of classes.
  • Some exceptions we have met: IOException, FileNotFoundException, NullPointerException, ClassCastException, NumberFormatException, CloneNotSupportedException.
  • Copy constructor vs. clone. deep vs. shallow. Problems with subclasses.
  • To write a correct clone method is tricky. The class should implement Cloneable. The method should be a deep clone, where all components that are not of a primitive type and not of an immutable reference type are cloned. It is considered proper to call super.clone() and to catch possible CloneNotSupportedException. Here is an example.
  • It is possible to declare classes within other classes, but we do not do it yet.
  • Binary representation of a number.
  • Printing the individual digits of an integer.
  • Raising x to the nth power. Iterative and recursive form. Performance improvement over naive implementation (multiply x by x n-1 times)? Does it work?
  • Writing a hash function (I know that Object gives us the method hashCode ..)
  • You might enjoy reading an article about startups.
  • Eleventh 5-minute test.

• 11/29/05 - Class on 11/29
  • Returned and discussed the tenth 5 minute test.
  • Abstract methods and abstract classes. For example Number is an abstract class with subclasses like Byte,Double, Float, Integer, Long, Short. Remember: Abstract classes are used as roots of a hierarchies of related classes.
  • Instance methods of a subclass can override the corresponding instance methods of the base class and be invoked depending on the dynamic type of the objects it is applied to. But static methods are invoked according to static types.
  • Remember the distinction shallow vs deep clone and equals.
  • Remember for class constructors: if no constructor is defined, then default is available; if some constructor is defined then you must define also the default; constructors are not methods - they return no value and they are not inherited. The copy constructor is a constructor that, given an instance of the class, returns a copy of that instance. Who defines this constructor will choose if to make a deep or shallow copy of the instance.
  • The final modifier. You saw its use with data members when defining constants. You can also use it with methods and classes. For classes it means that it cannot be extended (look for example at the API definitions of Integer, String, ..). For methods it means it cannot be overridden in subclasses.
  • Covariant return type: in Java 5 in a subclass if a method moo in the subclass overrides a method moo in the base class, moo in the subclass can return a type that is a subclass of the class returned by moo in the base class.
  • A class representing sets of integers and here is an alternative implementation.
  • Handed out last homework.
  • Class evaluation

• 11/19/05 - Class on 11/22
  • We can store "Item information" (CD, DVD, or GAME) into an ArrayList. In the ArrayList each item is seen as just an Item. We know that we can sort arrays of items. So we can move those items from the ArrayList to an array of items. But sorting can only be done on Objects that are Comparable (Comparable is an interface whose only method is compareTo). So Item must implement the interface Comparable: implement the compareTo method for item. Remember, there are no constructors for interfaces. Then we can use Arrays.sort on our array of items.
  • Another example of interface: Cloneable - it has no method, but it allows the Object.clone() method to do a field-by-field copy of its instances (remember, the instances of interfaces do not come about through constructors, but by assignments from instances of classes that implement the interface).
  • The class Object, in addition to equals, clone, and toString, as we have already seen, it has the method getClass that returns the class of an object. It is used as we see next.
  • The right way to write equals. Example for the Fraction class:
    public boolean equals(Object f) {
    if (f == null) return false;
    if (this.getClass() != f.getClass()) return false;
    return (this.num*f.denom == this.denom*f.num);
    In this way if a is a non null object and b is another object that is null, a.equals(b) will work correctly and return false. Note however that b.equals(a) will raise a NullPointerException - equals is not symmetric! [Note that the class Class is not cloneable (its instances are immutable), thus we can see if two instances of Class are equal by just comparing with ==.]
  • In a subclass we refer to the superclass as super. In fact we start a constructor of the subclass with a call to super(..). If we don't, the system will invoke automagically the default constructor of the superclass.
  • In the subclass we have all the data members of the superclass, plus perhaps, locally defined data members. But beware about access: if the superclass's data members have visibility private, we cannot get to them directly.
  • String, and all the wrappers for primitive types: Integer, Double, Character, Boolean, .. are immutable. The method clone does not apply to them as you can see by their API: they do not implement the Cloneable interface.
  • Revieweing primitive types. Representation of int and byte.
  • Tenth 5-minute test.

• 11/15/05 - Class on 11/17
  • Returned and discussed the ninth 5 minute test.
  • Merging sorted arrays, sorted files
  • Reading from a file a sequence on integers and storing them into an ArrayList. Beware: there may be zero or more integers on a line, separated by blank characters. The same program re-written to better use Java 5.
  • The constructor of a subclass should have as first statement a call to the constructor of its base class: super(..). If this call is absent the compiler inserts a call to the default constructor of the base class.
  • Access control to class members. The protected attribute. We thus have 4 different levels in access control. From less stringent to more stringent: public, protected, package private. Notice that package is the access control when we do not specify access control! So access is (a) everywhere, (b) in current package + any subclass, (c) only in current package, (d) only in the class.
  • Documenting Java programs: the javadoc tool.
  • For people who love challenges, here are some nifty assignments, the stuff to play with outside of course requirements.

• 11/13/05 - Class on 11/15
  • Polimorphism: early binding = eager behavior = use of static type; late binding = lazy behavior = using dynamic type.
  • Abstract methods and classes. An abstract class X can have constructors but cannot use them to construct X objects! The classes we have been defining were concrete.
  • Interfaces.
  • A class can extend multiple interfaces.
  • UML diagram with Object [concrete], Comparable [interface], Student [abstract], and GraduateStudent[concrete]. The 'extends' relation and the 'implements' relation.
  • If class A extends class B we say that A is a subclass of B, or that B is a superclass of A, or that B is the base class of A.
  • We can determine if an object is an instance of a class using the "instanceof" operator, as you see here - but usually we do not need to. There we see also the use of the method "getClass" that returns a class!
  • Five Minute test.
  • Handed out homework 12.

• 11/09/05 - Class on 11/10
  • Returned and discussed the 8th 5-minute test
  • More about insertion sorting
  • Rotating the elements of an array k positions to the left. We use cleverly the method for rotating the elements of an array.
  • Here is an example of how we can write our own random number generator.
  • More about ArrayList: converting to array, sorting that array. The elements of the array must be objects of a class the implements the Comparable interface by implementing the method compareTo.
  • Remember that the primitive data types are not classes. But we have wrappers for the primitive data types, classes like Integer, Double, Character, .. With auto-boxing and deboxing java 5 is making our life easier.
  • Extending a class
  • Here is an example of polymorphism.

• 11/04/05 - Class on 11/08
  • Exceptions. try .. catch .. finally .. throws .. throw ...
  • Checked vs. non-checked exceptions. Checked exceptions are exceptions that we want to handle when they occur (for example IOException and FileNotFoundException) while unchecked exceptions are exceptions that when they occur we want to get out and modify environment or program (for example, ClassNotFoundException - something wrong in environment; ArrayIndexOutOfBoundsException, ClassCastException - usually there is a logical problem in my program, ..).
  • You can declare your own exceptions if you think that there are not enough predefined exceptions.
  • Exceptions propagate until caught or the program is terminated.
  • Files: input vs. output, text vs binary files, sequential vs. random access. We stick to sequential text files.
  • An example of reading a text file using BufferedReader and using Scanner
  • Copying a file using BufferedReader and PrintWriter.
  • Readers and Writers vs InputStreams and OutputStream: sequences of characters or sequences of bytes. What "Buffered" does for you.
  • Exceptions are in Chapter 15 and text files in Chapter 16 of the textbook. You may find it useful to consult the slides for the textbook (accessible from course's home page).
  • Eleventh Homework
  • Eight 5-minute test.

• 11/02/05 - Class on 11/03
  • Returned and discussed second midterm
  • Some comments on Lab 9, including question about "good testing".
  • An interesting article on Physical Computing Systems
  • Some methods of the Object class: clone, equals, toString: Shallow vs. deep equals, Shallow vs. deep cloning.
  • We will have quite a bit more to say about Inheritance and ObjectOriented Programming, but we need to start working with files. For now let's not discuss all the complexities of files and see first exceptions.
  • Exceptions are objects. They are raised automagically by the system, or thrown explicitly by a throw statement written by programmer.

• 10/27/05 - Class on 11/01
  • Second Midterm
  • Homework 10 [and a possible solution for homework 9]

• 10/25/05 - Class on 10/27
  • Returned and discussed the seventh 5 minute test.
  • Introduced wrappers for the primitive types: Integer, Double, Character, ..
  • Autoboxing and deboxing (unboxing).
  • Java is an Object Oriented Language: We have seen Abstraction , Encapsulation, Overloading and the signature of a method. Now we start thinking about Inheritance and Polymorphism.
  • Every class extends the Object class.
  • Assignments in the class hierarchy. An example showing how we can move between the type Object and other types.
  • The static vs the dynamic type of a variable. Object polymorphism.
  • Introduced ArrayList class: size, get, add, set, indexOf, remove, toArray.
  • Parameterized ArrayList.
  • The Math class: things like random, abs, floor, ceiling, max, min, round, sqrt, .. random is very useful, though the class Random is more powerful. Here is an example of use of both.
    The second midterm is on Tuesday

• 10/20/05 - Class on 10/25
  • The mystery of the String[] args parameter of main: command line parameters.
  • Assigning an array vs cloning an array vs copying an array. In the first case two variables denote the same array. In the second, given a reference to an array, we return a reference to a new array that is a copy of the first. For example:
    int[] a = {1,2,3}; int[] b = (int [])a.clone();
    System.out.println(a == b); System.out.println(Arrays.equals(a, b));
    will print out "false" and "true".
    In the third case, given two references to arrays we copy some content from the first array to the second array. Here is an example. By the way Arrays.fill(arrayreference, value) fills the arrays with that value - for instance, given an integer array a, Arrays.fill(a, 3) initializes the components of a to 3.
  • Multi-dimensional arrays. Note that these arrays are jagged .. See for example this program.
  • Insertion sort.
  • More loop invariants, more complexities, more attempts at program understanding.
  • Enhanced for loop: for (type variable: "linear"object) S;
  • Homework 9 is on the web. [Possible solution for lab 8.]
  • Seventh 5 minute test

• 10/19/2005 - Class on 10/20
  • Returned and discussed the sixth 5 minute test.
  • Specified and implemented a function to print out an array with n elements, printing k elements per printout row.
  • Program Understanding: program complexity.
  • More discussion of linear search and selection sort.
  • Specified bubble sort (but not implemented).
  • Well, Java really already implements for us methods for sorting and binary search as you can see. But we want to learn the basics.
  • Selection sort on a String. Note that it cannot be a method like
          public static void sort(String s)
    It has to be something like
          public String sort(String s)
    because Strings are immutable. In the sorting method we use an array of characters and the conversion toCharArray from String to char[], and then a constructor of String from char[] to get back to String.
  • Discussed and implemented binary search - why the number of tests in a sorted array with n elements is proportional to the logarithm of n.
  • When we program we reason in English, not in Java, or C++, or whatever. And we move from English to the programming language conscious of the constraints imposed by the programming language. But the difficulty of programming arise more in the problems we need to solve than in the programming language we need to use. Think yourself as a craftman: we understand and love the tools we use (the language, OS, etc.) but we love them for what they allow us to do (build other and better tools, or applications).

• 10/14/05 - Class on 10/18
  • Aubrey Jones is now with us.
  • We have discussed the idioms for building a string using the idiom s1 += c, where s1 is a String and c a character; or the idiom s2.append(c), where s2 is a StringBuffer and c is a character.
  • Packages and (sub)directories. The main program uses a class Moo defined in the subdirectory called test. In the main program I put "import test.Moo;" In the file Moo.java defined in the subdirectory test I have to add the statement "package test;".
  • More about loops: do..while
  • We have discussed how to document a program: problem statement, problem analysis, design and algorithms, implementation, and testing. For each homeworks you should have a file "README" with that information, make it a simple text file, not a fancy Word or such document. Or you could place that information at the beginning of your program.
  • Program Understanding: We have discussed method preconditions and postconditions, loop invariants, algorithm complexity.
  • Review of terminology for classes and their methods: static vs instance data members and methods; constructors, accessors/selectors, modifiers/setters, worker classes vs application classes; drivers and stubs; subject of a method invocation = a class name or an object reference.
  • Beware of equals for arrays. The Arrays class may help.
  • Specified and implemented a static method to reverse an array.
  • Given the eigth homework.
  • Sixth 5 minute test.

• 10/12/05 - Class on 10/13
  • Returned and discussed 5-minute test.
  • Discussed the sixth homework.
  • Specified and implemented a static method to sort an array (selection sort).
  • We have distinguished between "worker" or "server" classes, and "client" classes and "applications".
  • It is a good idea to place a main program also in worker classes: this main program should be the tester for the worker class.
  • We note that we are in the business of using existing classes and of defining new classes. At times we give our own implementation to existing classes just to make experience and better understand them.
  • Conditional expression: e1?e2:e3, where e1 is boolean: the value is the value of e2 if e1 is true, of e3 otherwise.
  • Abbreviating assignments: we can write things like account_balance = account_balance + 32.43; as account_balance += 32.43;

• 10/07/05 - Class on 10/11
  • Because lucas was down most of yesterday, the dealine for homework 6 has been moved to tonight at 10pm. But the next homework is being handed out today.
  • We have mentioned that methods may be overloaded (they may be with same name and different signatures [method name plus, in sequence, the types of its formal parameters].
  • We do not know how to format numbers. Java used to use the NumberFormat class. Now it uses (also) formatted output: study section Advanced Topics 4.7. Here is an example of using formats.
  • Can we get by without having to learn new APIs by programming? Yes, but it is hard work.
  • One dimensional arrays: their components are accessed by subscripting; they can be assigned; they can be compared (on the basis of their addresses); they are object references; the order of an array (i.e. the number of elements in the array) can be known either at compile or at run time; we can initialize an array with an aggregate (something like {7, 11, 4, 2}).
  • Some simple methods on arrays: finding an element, finding the largest element, reversing an array, ..
  • Homework 7
  • We have a 5 minute test

• 10/04/05 - Class on 10/06
  • Returned and discussed the fourth 5 minute test.
  • Just touching on inheritance and the Object class.
  • The intent of the methods: equals, toString, clone. A clone method for the Fraction class.
  • Reasoning about programs: Preconditions, postconditions, loop invariants.
  • Printing all the substrings of a given string.
  • Given a string, say "philadelphia", produce a string that consists of the unique characters in the string, so "philade".
  • We know about about constructors, accessor/selectors, modifiers/mutators, help/auxiliary methods.
  • We have discussed parameter passing. All parameters are passed by value (Remember, for reference types we pass the reference, not the object.) and this has consequences on what can and cannot be modified. We have seen that methods can have or not parameters, return or not values, for a total of four cases.
  • The StringBuffer class: strings that are mutable. An example.
  • Even better, for us who do not do concurrency, it is StringBuilder.

• 09/29/05 - Class on 10/04
  • Parameters are passed by value. Trouble writing a 'swap' method.
  • Debugging vs. Testing.
  • Method stubs, method/class drivers
  • The switch statement (case:, default:, break;);
  • The encode function for previous homework.
  • The boolean operators && and || have a shortcut evaluation (also called "conditional and" and "conditional or"). Instead & and | always evaluate their arguments.
  • The order of evaluation of conditions matters. Suppose we are looking for people who are young and rich and we are told that 50% of the people are young and 5% are rich, what should we test first, for youth or for wealth?
  • Diagrammatic notation for a class (from UML)
  • More about String: there is a big difference between Strig s1 = null; and String s2 = ""; The first is a null reference, not addressing any object. The second is a reference to an object, a String, whose value is "". If I say s1.length() I get an exception; if I say s2.length() I get 0.
  • More about String. The compareTo and compareToIgnoreCase methods (using lexicographic ordering).
  • The sixth homework.
  • The fourth 5-minute test.

• 09/27/05 - Class on 9/29
  • Returned and discussed the first midterm.
  • The textbook comes with slides
  • More discussion on strings. Given a string, produce string obtained by replacing substrings with other substrings. Count the number of occurrences of a string in another.
  • Given a string s representing an integer, say "392", we obtain the represented integer with Integer.parseInt(s) - similar for double ..
  • Given an int variable x with value, say, 358, we compute its value, without using Java API, as a string in decimal notation, in octal notation, in binary notation, and, why not, in hexadecimal notation!
  • For a long time we will have to talk about the scope of identifiers.
  • Errors: syntactic, semantic, logical; compile time vs. runtime.

• 09/26/05 - Class on 9/27
  • Tomorrow we have the first Midterm.
  • We'll hand out the fifth homework

• 09/20/05 - Class on 09/22
  • Returned and discussed the third 5-minute test.
  • Things like x++, ++x, --x, x--, x += 3; x *= 5;
  • return, break, continue
  • We have seen how we can enumerate the factors of an integer
  • Determining if an integer is a prime.
  • Next Tuesday we have the first midterm. Read your class notes, the homeworks, and the textbook as indicated here.

• 09/16/05 - Class on 09/20
  • In addition to the TA for the course, Ms. Prasanna, there is now a Help Desk in Room 208 Wachman Hall for the introductory classes such as cis67 with this schedule. In addition we have a lab assistant, James Kling
  • Defining constants: static and final.
  • We have seen that the initial value of an object reference is "null" for non-local variables (i.e. for data members) but undefined for local variables. Similarly for data members that are of primitive types, they are given a default initial value (0 for numeric types); but local variables with primitive types are with undefined content.
  • We know what are method calls, formal parameters, actual parameters. Parameters are passed by value: in the case of primitive types, the value of the variable (an int, or a double, or ..) is copied to the method; in the case of reference variables, the value of the reference, not the object being referenced is copied to the method.
  • We have repeated the distinction between static and instance attributes (data members), static and instance methods.
  • Review of syntax seen up to now.
  • Conditional statements (but not switch): various forms of if statement.
  • Loop statements: while, for.
  • Third 5-minute test.
  • Fourth homework

• 09/14/05 - Class on 09/15
  • We have seen assignments, automatic conversions, and the use of casting.
  • Operator precedence and parsing an expression.
  • We have seen expressions, operators and their precedences.
  • We have seen in the case of Fractions the difference between == and equals.
  • We have seen integer codes of the ASCII characters and covenient methods in the Character class
  • We have seen some methods of the String class: length, charAt, indexOf, substring, compareTo. Remember, Strings are immutable: there is no way to change in place the content of a String.

• 09/09/05 - Class on 09/13
  • Returned and discussed the first 5 minute test.
  • Seen, but not carefully, what is an identifier in Java and what are the keywords.
  • In comparing fractions we need to normalize them. A fraction is normalized if its denominator is positive and numerator and denominator are relatively primes. For example, 18/-24, normalised is -3/4. We used Math.abs(..) [Question: is abs a "static" or "instance" method?]. We used the gcd method to make two integers relatively primes. We showed a method in the Fraction class that computes the gcd of two numbers using the Euclidean algorithm:

       // Precondition: a!=0, b!=0
       public static int gcd(int a, int b){
          int r = a%b; // 48%30=18, 48%30=-18, -48%30=-18, -48%-30=-18
    		   // i.e. the sign is the sign of the dividend and
    		   // the value, in absolute, is the same independent 
    		   // of sign. The divisor must be != 0, but dividend
    		   // can be 0.
          while (r != 0) {
    	 a = b;
    	 b = r;
    	 r = a%b;
          }
          return Math.abs(b);
       }
    

  • We have reviewed the primitive data types. We know various integer types, real types, booleans, and characters.
  • We have seen how integers are represented. We have seen how floating point (real) numbers are represented. Don't worry: I will not ask about their representation in exams. But it is stuff you will meet again in other courses like cis72 and you will need to know.
  • We have seen that we can have overflow and roundoff errors.
  • We have seen the meaning of "this".
  • Handed out and discussed the third homework
  • Done second 5 minute test.

• 09/06/05 - Class on 09/08
  • We sort of know what are primitive data types (int, long, short, byte, double, float, char, boolean), object references, some declarations (variable declarations, simple classes, and methods), executable statements (assignment, input, output, method call). We need to go carefully again over this material. But we should be able to write small programs consisting of one or two classes.
  • A class has members. Some of them are data members, others are constructors, others are methods. We have seen accessor and setter methods. We have seen the qualifiers public and private. We have seen the qualifier static.
  • Methods can have parameters and return a value.
  • We have talked briefly of classes and instances but we need to say much more about them.
  • We have used in a very primitive way strings and input and output streams.
  • We have discussed the Fraction class and given some of its code.
  • We are doing chapters 2, 3, and 4!
  • When uncertain, we try simple programs, we talk with our colleagues, we ask the TA, we ask the teacher. And of course we first read the book.
  • Done first 5 minute test.

• 09/02/05 - Class on 09/06
  • Last Tuesday we did the first chapter.
  • This week we jump through the second, third, and fourth chapters! Don't be afraid: we will go over this material many times.
  • Object orientation: Classes and their instances.
  • Looking at the program (your first homework) we wrote in the lab on Thursday: syntactic elements.
  • What we find in a java source file: comments, [package statement], import statements, public class with same name as file, possibly private classes.
  • What we find in a class: comments, static (or class) data members, static (or class) methods, constructors, (instance) data members, methods.
  • Here are the code conventions recommended for Java. It is probably more than what you need, but it is a good reference nonetheless.
  • Looking back at things we have already seen: methods, method invocation, variables.
  • Handed out and discussed the second homework

• 08/31/05 - Class on 09/01
  • WE ARE MEETING IN THE LAB: Room 108 in Wachman Hall
  • We receive accounts on both Windows (on Nova) and Linux (on Lucas).
  • We will use java in the simplest way: we create a program with a text editor, we compile it at the command prompt with javac, we run it at the command prompt with java.
  • Today in Windows we cannot use java because it has not been set properly - it will be ok for the lab on Tuesday.
  • We use java by connecting to lucas using putty.
  • We see a few unix commands like, mkdir, ls, cd, more, mv, cp, rm, ..
  • We edit with pico. You will email to me your assignment. Use pine or whatever other email client you like.
  • I recommend that at home you install putty for telnetting to Temple's computers, and that that you install jdk-1_5_0_04.
  • Next lecture, on Tuesday, will be back in our usual room 1A in Tuttleman.

• 08/30/05 - Class on 08/30
  • We have gone over the syllabus in its various aspects, objectives of the course, people involved, text book, grading, etc.
  • We have discussed IT careers
  • We have discussed what is a computer system, with its CPU, main memory, secondary storage, bus, input, and output. We have done this mentioning things like bytes, megahertz, nanoseconds, ..
  • We have discussed Java and seen why it is "write once, run anywhere".
  • We have seen where to find information about Java's classes: http://java.sun.com/j2se/1.5.0/docs/api/.
  • Read Chapter 1.
  • Handed out first homework. Because of Labour Day, the deadline is 8:30am next Tuesday. In the future homeworks will be due by 10:00pm on Mondays.
  • Today in the afternoon there should have been a lab: It is cancelled. The course does not yet have a TA and I am at that time in class until 4pm.
  • On Thursday the class will meet in the lan, in Wachman 108. In the lab we will hand out the accounts for the course. We will see how to log on Unix and on Windows. We will see how to edit a text file, how to compile it, how to run it. We will see how to send a program to the instructor using email.

• 07/22/05 - Before Class on 08/30/2005
  • This is hard to do, since probably you will not look here until after the first day of class. But if you can, try to review what you learned in previous programming classes, if any. Start reading the first couple of chapters of the textbook.
    On the first day of class I will give you an anonymous test. This test will test how much you know entering the class and gives you a hint of what you are expected to already know.
    Notice that I have already posted your first homework.