This site will look much better in a browser that supports web standards, but it is accessible to any browser or Internet device.

SMART-ICS core knowledge and skills chart

Core Knowledge and Skills
ICS 21/CSE 21: Introduction to Computer Science I

Other courses:
6D | 22 | 23 | 51 | 52 | 132

Sections:
Catalog Description   |   Course Prerequisites   |   Restrictions   |   Prerequisite Skills and Concepts   |   Minimum Knowledge and Skills
ICS 21/CSE 21
Catalog Description		 First of a three-quarter introductory sequence. Introduces fundamental concepts related to computer software design and construction. Develops initial design and programming skills using a high-level language (currently Java). Introduces useful computer-based tools for analysis, expression, and discovery.
ICS 21/CSE 21
Course Prerequisites

None.
ICS 21/CSE 21
Restrictions		 Only one course from ICS 21/CSE 21 or ICS H21 maybe be taken for credit.
ICS 21/CSE 21
Knowledge Prerequisites: Skills and Concepts		 There are no course or subject matter prerequisites for ICS 21.

Students should have these computing skills when they enter the class, or learn them independently in the first week of the quarter:

  • Read and send electronic mail
  • Locate and view web pages by URL or using a search engine
  • Navigate web pages using a web browser
  • Read Adobe Acrobat (PDF) documents on line
  • Produce documents using a word processing program
  • Traverse a directory of files using the operating system in the lab (currently Windows)            
ICS 21/CSE 21
Minimum Knowledge and Skills		 Programming Fundamentals
  •  
    • Write programs in Java using the following language features:
      • Basic statements (assignment, I/O)
      • Basic data types (int, long, double, boolean)
      • Selection (if)
      • Loops and loop control (for, while, do; the dangers of break and continue)
      • Methods/functions (defining, calling, parameter passing)
    • Mastery
  •  
    • Write programs in Java that demonstrate proficiency in scoping rules (i.e., public vs. private, fields vs. local variables).
    • Understand the distinction between 'if' and 'switch' statements, including the pitfalls and advantages of each.
    • Proficiency
  •  
    • Recognize the need for the float and char data types.
    • Learn about, but not necessarily write, programs using simple recursion.
    • Recognize why exceptions occur during program execution.
    • Exposure
Data structures
Identify the appropriate uses of these data structures, and be able to read code to determine whether they are properly and reasonably implemented. For those data structures for which mastery or proficiency is required, write code that uses those structures.
  •  
    • Strings
    • Mastery
  •  
    • ArrayLists, including common methods, iteration, and specifying a type parameter.
    • Proficiency
  •  
    • Nested data structures (e.g., objects within ArrayLists).
    • Exposure
Conventional algorithms
Recognize problems where each of the following algorithms is appropriate.
  •  
    • Computing the sum, average, minimum, and maximum of a collection of numbers.
    • Traversing an ArrayList, applying an operation to each element.
    • Moving within, adding items to, and deleting items from a list, implemented as an ArrayList.
    • Mastery
Object orientation
  •  
    • Use existing classes.
    • Make simple modifications to a class definition.
    • Define and use instances of classes appropriately.
    • Mastery
  •  
    • Use method overloading (e.g., constructors with different signatures).
    • Design a simple new class with constructor(s), methods, and fields.
    • Use predefined class families.
    • Proficiency
  •  
    • Recognize the utility of the OO paradigm.
    • Decompose a simple problem into an object-oriented solution.
    • Extend a straightforward object-based design.
    • Gain a basic conceptual understanding of the use of generic types.
    • Gain a basic conceptual understanding of inheritance.
    • Exposure
Program design and implementation
  •  
    • Enter, run, and modify code using Java.
    • Mastery
  •  
    • Write a program, given a prose specification and possibly the description of available library routines (either standard Java or instructor-provided), within a provided skeleton, applying the mastery- and proficiency-level topics listed above, as appropriate to solve a new problem in a familiar domain.
    • Design and implement tests that demonstrate the correctness of these programs.
    • Follow specified coding style guidelines.
    • Appreciate the utility of coding style guidelines.
    • Locate and correct simple errors in code.
    • Proficiency
Programming skills
  •  
    • Write methods for a class.
    • Debug a program with the help of 'print' statements or a visual debugger.
    • Thoroughly test a small program.
    • Mastery
  •  
    • Write a complete program that uses two existing class definitions, where an object of one class uses information provided by an object of the other class.
    • Implement unit tests that demonstrate that functionality adheres to specifications.
    • Proficiency
Return to top of page