CSC 142

Chapter 1: Intro to Java

Sections:

1.1 Basic computing concepts

1.2 And now, Java

1.3 Program errors

1.4 Procedural decomposition

1.5 Case study: DrawFigs

Note: the first chapter is definitions-heavy.

Section 1.1: Intro to Java

Definitions

• Algorithm
• Program
• Hardware ("Hardware: the part of the computer that you can kick")
• Software
• Digital
• Binary
• Program execution
• Compiler
• Java Virtual Machine (JVM)
• Java Runtime Environment (JRE)

Material

Things to cover:

• Java class libraries (standard library)
• Java programming environment
• Java Hello World program
• Eclipse editor ("Why can't Java programmers see well?" "Because of the Eclipse.")
• Console window/command line

Quotes

1995: Oracle: "Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture-netural, portable, high-performance, multithreaded, dynamic language."

Life Skills

Life skills track:

• Pay attention and FOCUS
• RTFM
• Follow directions and read carefully
• Whether it's your compiler, or your instructor, or your fellow students - pay attention to what's being said
• Skill will pay off when you start to compile your Java programs

Section 1.2: Java

Materials

Class

• Every program, all Java code, lives in a class
• Class header
• Class methods
• Statements
• String literals
• System.out.println
• Escape sequences
• print vs println

Complex example: draw figures

• ASCII diamond, X, rocket

Code comments, white space, readability:

• Comments

Profiles

• James Gosling - Oracle, tech companies, open source vs. enterprise, hackers vs suits

Section 1.3: Syntax Errors

Material

Different types of errors:

• Where the errors happen - the normal process - (code) --> (compiler) --> (bytecode)
• Errors at compiler level - syntax errors - book lists common syntax errors
• Errors at code level - bugs - errors in the logic of the program (wrong idea, or right idea but implemented wrong)

Pofiles

• Grace Hopper

Section 1.4: Procedural Decomposition

Materials

Decomposing complexity:

• Decomposition concept: split into functions, tasks, subtasks

C is very verb-oriented, action-oriented

Java is very noun-oriented, object-oriented

Procedural programming:

• Function-based, action-based programming
• How to decompose task of baking a cake
• Static methods (help serve function of.......... functions)

Object oriented programming version:

• c = new Cake(); c.make()
• Encapsulating complexity of the object
• Example in book: drawBox, drawTopX, drawBottX

Flow control

• How control changes with function calls
• Objects: with OOP it becomes more complicated to follow the flow of the program
• Procedural programs and interpreted languages: you just start at the top and go from there
• Objects: "when is this code actually used?" (have to dive in to see)
• Learning to follow program flow control
• Flow control allows you to abstract away detail
• Example runtime error

Definitions

• Decomposition
• Iterative enhancement
• Static method
• Method call
• Flow control

Life Skills

Life skills track:

• Cover non-word representations of programs

(Give them a crypto puzzle, but we haven't introduced any crypto or codes just yet)

Section 1.5 : Case Study with DrawFig

Material

Modularization of drawing program

• Breaking int pieces - not just the box, or the x, or the rocket
• but breaking down into common components, common to all parts of the program
• Take hello world program...
• Modularize it, make it reusable...

Chapter 1 Summary

Worksheet: definitions from book on one side (quiz material)

Source code for a procedural program (fizz baz foo bar buzz bam) on the other

There are N bugs, find the N bugs (self-work)

Discuss the program flow with a partner (group work)

How do we represent this program in a clear and concise way?

Transform foo bar into get ready for school - proper names can help clarify understanding

Lecture: broken up into 1.5 parts

• Broad brush-stroke over chapter 1
• Memorize definitions
• Know XYZ for quiz
• Spend a majority of time on in-class exercises
• FOCUS: KNOW HOW TO RUN/SET UP HELLO WORLD
• FOCUS: KNOW DEFINITIONS
• FOCUS: KNOW FUNCTIONS AND PROGRAM FLOW
• FOCUS: KNOW ERRORS/EXCEPTIONS

Quiz/exam/assessment material:

• Hello world, basics, public static void main, syntax
• Definitions matchup
• Functions questions
• Program flow questions
• Exceptions: spot the bug... spot logical errors... spot syntax errors...

Need to make beginnings of class difficult, to send the message that they can't let it slide

Deliverables

Intro to Java

• Know how to set up and run hello world
• How does it work, role of compliler vs editor
• JRE vs JVM vs JDK
• Public static void main
• EEverything is a class
• Filename = class name
• Correct syntax, protected keywords

Definitions

• algorithm, program, hardware/software, digital, binary, program execution, compiler, JVM, JDK, JRE, class header, class methods, statements, string literals, system.out.println, escape chars, print vs println, exception, decomposition, flow control, iterative enhancement, static method

Functions and program flow

• How to follow the flow of a program through multiple (nested) function calls
• When to use a static method or static class
• How to follow a nested program
• How to break up a task into less complex parts, with reusability
• Translate between procedure and function

Errors and logical problems

• Spotting the error
• Red herring: error, plus (unclear) compiler output

Chapter 2: Primitive Data and Definite Loops

Sections:

2.1 Basic data concepts

2.2 Variables

2.3 The for loop

2.4 Managing complexity

2.5 Case study: Hourglass figure

Note: this chapter has two halves. The first half examines expressions, particularly for numerical data and variables. The second half examines control structures, used to perform repetitive actions.

The goal here is pattern-finding - what repeated actions will lead to the desired outcomes? This loop will cover definite loops (loops that repeat a predetermined number of times). Next chapter will cover indefinite loops.

Section 2.1: Basic data concepts

Material

Java primitive types:

• int
• double
• char
• boolean

Why important? because computers represent data and numbers in memory, and we need to understand how (rules)

How we input data and operations:

• literals (literal values, 2.19)
• expressions (assembling stuff, related by operators)

Operators:

• Mix of computer science and math
• Operators mean, performing a set of tasks (or, a task)
• Some operators require 2 things, e.g., 2+3
• Some operators require 1 thing, e.g., inverse(A) or d/dx( x^2 )

Literals

• Different data types
• Decimals vs integers (especially with operations)
• Booleans: true/false (keywords)

Arithmetic

• Division weirdness
• Remainder operator
• Goldfish analogy - small memory capacity - 2 digits - what happens after 99? start over

Precedence and order of operations

• Grammar connection
• Be explicit in what you're asking computer to do

Casting and file types

• can deal with int/float differences by casting
• Again, be explicit: (int)( ......... )

Definitions

Definitions:

• Data type
• Expression
• Evaluation
• Operator
• Precedence
• Casting

Profiles

Charles Babbage - digital representation

Section 2.2: Variables

Materials

You have to declare it available in order to use it

You have to declare what kind of variable it is

Can combine declaration and assignment

Can declare multiple variables on one line

Concat:

• To combine strings, use plus operator
• But be careful with number/string types
• Example: 2 + 3 + " hello " + 7 + 2*3
• Multiplication first
• Then only addition is left, so evaluate left to right
• 2+3 first becomes 5
• Then the remaining plus operators turn into string concatenation operators
• Better: be explicit about what types are being added to what, and in what order.

Increment/decrement:

• Useful shorthand operators

Definitions

Definitions:

• Variable
• Declaration
• String concatenation
• Increment/decrement

Section 2.3: For Loop

Material

Purpose:

• Replace redundant tasks

Syntax of for loops

• Initialize a loop variable, create a condition
• Body of for loop is executed if condition is true
• Tracing loops
• Curly braces are important

Some patterns:

• If we want to execute a loop N times, can use two patterns: i=0, or i=1
• Nested for loops
• Print vs println with nested for loops

Definitions

Definitions:

• Control structure

Section 2.4: Managing Complexity

Material

Scope:

• Helps to manage complexity of variable space
• Curly braces represent scope
• Variable defined inside braces is not defined outside those braces

Examine examples, errors, why it crashes, and how it crashes

Tracing a for loop:

• Initialization
• Test
• Body
• Update
• End

Pseudocode:

• Part of communicating about code
• Simple examples to give them an idea
• More complex pattern-finding, indices (2(i-1)), etc...
• Constants (for drawing patterns, e.g., number of lines)
• Public static final type name = (...) <-- permanently, same value, accessible by stattic methods
• We are still thinking PROCEDURALLY

Definitions

Definitions:

• Scope
• Localizing variables
• Infinite loop
• Pseudocode
• Class constant

Section 2.5: Case Study: Hourglass Figure

Detailed example of how to work out a pattern and translate it into modular code

Chapter 2 Summary

Deliverables:

• Primitive type expressions and literals
• Casting
• Assigning/changing variable values
• For loops, for loop patterns
• Scope
• Pseudocode
• Constants

Assessment Material

Dealing with primitive types in expressions, and order of operations, etc.

• How to interpret incrementing and other assignment operators
• For loops:
  • Know how to follow control
  • Syntax
  • Curly braces
• Scope
• Pseudo code to describe how to draw a pattern
• Constants
  • Syntax
  • Explaining the purpose (e.g., which of the following would be a good variable to program as public static final z)
• 99 bottles of root beer