Latest revision as of 16:05, 24 September 2016

Chapter 1: Intro to Java
- Java basics
- Program errors
- Procedural decomposition
- Case Study: DrawFigs
Chapter 2: Primitive Data and Definite Loops
- Basic data
- Variables
- For loop
- Managing complexity
- Case Study: Hourglass figures
Chapter 3: Parameters and Objects
- Parameters
- Methods returning values
- Using objects
- Case Study: Projectile trajectory
Chapter 4: Conditional Execution
- If/else statements
- Logic statements
- Object equality and operators
- Refactoring to use if/else logic
- Cumulative algorithms
- Equality with floats and roundoff error
- Text processing
- Printf
- Methods and conditional execution
- Case Study: BMI

Midterm B

Midterm B Outline

Chapter 5: Program logic, conditional execution
- While loops
- Random numbers
- Fencepost algorithms
- Boolean type
- User input and dealing with errors
- Assertion and program logic
- Case Study: NumberGuess
Chapter 6: File processing
- File reading basics
- Token based processing
- Reading numbers from a file
- Paths and directories
- Line based processing
- Line/token combinations
- Advanced file processing
- Removing whitespace
- Case Study: Zip code lookup
Chapter 7: Arrays
- Array basics and initialization
- Comparing arrays
- Array traversal
- Reference semantics and memory, and null
- Advanced array techniques
- Shuffling, shifting, reversing
- Multidimensional arrays
- Rectangular multidimensional arrays
- Jagged multidimensional arrays
- Case Study: Benford's Law
Chapter 8: Object oriented programming
- Object state and behavior
- Accessor methods
- Object initialization and constructors
- Data encapsulation
- Private fields
- Mutable/immutable
- Case Study: Stock class

Flags

The short list of topics:

Intro to Java

Primitive Data and Definite Loops

Parameters and Objects

Conditional Execution

Program Logic and Conditional Execution

File Processing

Arrays

Classes

CSC 142: Difference between revisions

From charlesreid1

Latest revision as of 16:05, 24 September 2016

Contents

Chapter 1: Intro to Java

Chapter 2: Primitive Data and Definite Loops

Chapter 3: Parameters and Objects

Chapter 4: Conditional Execution

Chapter 5: Program Logic and Indefinite Loops

Chapter 6: File Processing

Chapter 7: Arrays

Chapter 8: Classes

Outline

Midterm A

Midterm B

Flags

@@ Line 1: / Line 1: @@
+See [[CSC 142 Checklist]]
 =Chapter 1: Intro to Java=
-Sections:
+[[CSC 142/Chapter 1]]
-.1 Basic computing concepts
+=Chapter 2: Primitive Data and Definite Loops=
-.2 And now, Java
+[[CSC 142/Chapter 2]]
-.3 Program errors
+=Chapter 3: Parameters and Objects=
-.4 Procedural decomposition
+[[CSC 142/Chapter 3]]
-.5 Case study: DrawFigs
+=Chapter 4: Conditional Execution=
-Note: the first chapter is definitions-heavy.
+[[CSC 142/Chapter 4]]
-==Section 1.1: Intro to Java==
+=Chapter 5: Program Logic and Indefinite Loops=
-===Definitions===
+[[CSC 142/Chapter 5]]
-* Algorithm
+=Chapter 6: File Processing=
-* 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===
+[[CSC 142/Chapter 6]]
-Things to cover:
+=Chapter 7: Arrays=
-* 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===
+[[CSC 142/Chapter 7]]
-: Oracle: "Java: A simple, object-oriented, network-savvy, interpreted, robust, secure, architecture-netural, portable, high-performance, multithreaded, dynamic language."
+=Chapter 8: Classes=
-===Life Skills===
+[[CSC 142/Chapter 8]]
-Life skills track:
+=Outline=
-* 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==
+==Midterm A==
-===Materials===
+Midterm A Outline
+* Chapter 1: Intro to Java
+** Java basics
+** Program errors
+** Procedural decomposition
+** Case Study: DrawFigs
+* Chapter 2: Primitive Data and Definite Loops
+** Basic data
+** Variables
+** For loop
+** Managing complexity
+** Case Study: Hourglass figures
+* Chapter 3: Parameters and Objects
+** Parameters
+** Methods returning values
+** Using objects
+** Case Study: Projectile trajectory
+* Chapter 4: Conditional Execution
+** If/else statements
+** Logic statements
+** Object equality and operators
+** Refactoring to use if/else logic
+** Cumulative algorithms
+** Equality with floats and roundoff error
+** Text processing
+** Printf
+** Methods and conditional execution
+** Case Study: BMI
-Class
+==Midterm B==
-* 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
+Midterm B Outline
-* ASCII diamond, X, rocket
+* Chapter 5: Program logic, conditional execution
+** While loops
+** Random numbers
+** Fencepost algorithms
+** Boolean type
+** User input and dealing with errors
+** Assertion and program logic
+** Case Study: NumberGuess
+* Chapter 6: File processing
+** File reading basics
+** Token based processing
+** Reading numbers from a file
+** Paths and directories
+** Line based processing
+** Line/token combinations
+** Advanced file processing
+** Removing whitespace
+** Case Study: Zip code lookup
+* Chapter 7: Arrays
+** Array basics and initialization
+** Comparing arrays
+** Array traversal
+** Reference semantics and memory, and null
+** Advanced array techniques
+** Shuffling, shifting, reversing
+** Multidimensional arrays
+** Rectangular multidimensional arrays
+** Jagged multidimensional arrays
+** Case Study: Benford's Law
+* Chapter 8: Object oriented programming
+** Object state and behavior
+** Accessor methods
+** Object initialization and constructors
+** Data encapsulation
+** Private fields
+** Mutable/immutable
+** Case Study: Stock class
-Code comments, white space, readability:
+=Flags=
-* Comments
-===Profiles===
-* James Gosling - Oracle, tech companies, open source vs. enterprise, hackers vs suits
-==Section 1.3: Syntax Errors==
-===Material===
+{{CSC142Flag}}
-Different types of errors:
+The short list of topics:
-* 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
+Primitive Data and Definite Loops
-* 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
+Parameters and Objects
-* Spotting the error
-* Red herring: error, plus (unclear) compiler output
+Conditional Execution
-=Chapter 2: Primitive Data and Definite Loops=
+Program Logic and Conditional Execution
-Sections:
+File Processing
-.1 Basic data concepts
+Arrays
-.2 Variables
-.3 The for loop
-.4 Managing complexity
-.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: <code>2 + 3 + " hello " + 7 + 2*3</code>
-* 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
-=Flags=
-[[Category:Teaching]]
+Classes