The exam will be in class, and you will have the full time to complete it. A well prepared student will have no problems being done in 120 minutes, but you will have 3 hours if you need it. It will be closed book, closed notes, closed laptops, closed cell phones, closed bricks, closed everything and no discussions allowed with class mates during the exam.
Here is a list of topics that you should be able to explain or use in a program. Understanding these topics well will help you do well on the exams.
This is a guide, not a guarantee. I intend for it to help you, but questions on the exam can come from any material we have studied in this class.
basic data (number, string, boolean)
operations on each type
all of the "big 6" topics
1) data storage to memory: variables, assignment
2) data retrieval: expressions, evaluation
3) decision making: conditional statements
comparisons, boolean conditions
if-then
if-then-else
if-then-elseif-elseif-else
switch
4) repetition: loops
definite loops (for)
indefinite loops (while)
break statement to end a loop
return to end a loop (and end execution of a function)
5) procedure abstrations:
writing functions
functions are first class objects
a function can be assigned to a variable
calling functions
understand how parameters are passed
from the calling function to the called function
understand how return values are sent back
from the called function to the calling function
6) data abstraction: aggregation (arrays)
creating arrays
using arrays (indexing, using for loop to access all items)
getting length of array
ALL programming languages in general use allow all of the
big 6 concepts to be expressed
objects
what they are:
an abstraction of an entire program
data and functions combined, wrapped up
data field (variable in an object)
method (function in an object)
objects
how we create one
how to initialize one
how to use one, how to access the data fields and call the methods
return data as a group with an object (an object that has no functions/methods)
constructors: functions that "manufacture" and return new objects
arrays of objects
object that contains an array as a data field
what you learned in your assignments:
sorting (bubble sort)
searching
linear search through an array
binary search (number guessing game)
finding prime numbers (sieve of eratosthenes)
scope: visibility of names
local scope
variables declared inside a function
parameters inside a function
global scope
functions at the top level
variables declared outside of all functions (we dont use these)
object scope
using "this" to access a data field from inside a method
input mechanisms
prompt statement
getting text from a prompt text box via cut-n-paste
"parsing" text using string.split
output mechanisms
alert statement (useful when debugging)
canvas drawing
converting text to numbers
recursion...
what is it,
why we use it,
what is the basic coding pattern for a recursive function
simple example (like factorial or your bricks)
simulated execution
show memory map for local variables
show how variable values are assigned and change
show how memory maps are created for a function call
show how parameters are passed when function is called
show how return values are sent back to calling memory map
good coding practices
using named constants instead of explicit numbers in code
named constant is a variable that is initialized
and then not re-assigned, so its value does not change
write a few lines of code, compile, and test
dont write a large block of code and hope it all works
grow a program a little piece at a time
add capabilities one thing at a time
input data validation
comment the code at places that could be hard to understand
dont use global variables (unless you are testing and are using
them temporarily)
write functions to prevent replicating blocks of code throughout
your source code
write functions to make code more compact and easier to read
abstract away some details into the function body