Course Objectives

By the end of the course, students should be able to demonstrate the following knowledge and skills:

Subtopic Knowledge Objectives Skill Objectives
1. General Knowledge and Process Objectives
1.1. Computers, 
Hardware and Software
  • Explain the functioning of a computer as an electronic system for input, processing, memory, storage, output and communication of information and data.
  • Differentiate hardware and software.
  • List or identify and explain the major hardware and software components of a computer system and their interaction to produce a working system.
  • Explain hardware components such as CPU, RAM and ROM memory, secondary storage devices, and I/O and communication components.
  • Differentiate system software, application software and operating systems.
  • Differentiate software, program and programming language.
  • Differentiate and classify languages as low and high level languages.
  • Differentiate machine language and assembly language.
  • Compare features and strengths of popular programming languages such as C, C++, Java, JavaScript, and Visual Basic.
  • Switch on the computer and start the operating system.
  • Use command-line and graphical user interfaces.
  • Find, run, switch, hide and terminate applications.
  • Find, list, view, move, rename, copy, create and delete files and directories.
  • View and edit text files.
  • Search for, view and navigate hypertext documents in on-line help, the UMU Intraweb and the World Wide Web.
  • Use Web-based electronic mail to send and receive messages and attachments.
1.2. Programming
  • Differentiate assemblers, compilers, linkers and interpreters.
  • Differentiate shells, editors and debuggers.
  • Explain the relationship between source, object and executable code.

  • Differentiate compile-time and run-time errors, syntax and logical errors, verification and validation.

  • Define user interface and differentiate command-line and graphical user interface.

  • Differentiate algorithm, pseudocode and flowchart.

  • Differentiate syntax and semantics.

  • Define programming, editing, compiling, linking,  interpreting, running, debugging.
  • Design, code, compile, run, test, debug, document and manage programs.
  • Use appropriate software development tools including operating system shell and commands, code and text editors, compilers, linkers, debuggers, and paper and electronic manuals/documentation.
  • Convert between task specifications, algorithms, flow charts, pseudocode and program code.
  • Divide a large task into sub-tasks (decomposition).
  • Design a user-friendly interface.
  • Trace the operation and explain the purpose of a given program.
  • Use output statements for debugging.
  • Write code to check for and handle common errors such as divide by 0.
  • Identify and correct common programming mistakes.
  • Find, classify and correct a program's errors.
  • Modify, enhance, add to or redesign a given program or algorithm.
1.3. Documentation
  • Describe differences in program documentation for end users, programmers and managers.
  • Describe different types of program documentation (comments, manuals, tutorials, context-sensitive help).
  • Use comments to explain or disable/hide code.
  • Write organised, brief, clear, useful program documentation and user instructions.
  • Use on-line programming documentation including the Java 2 API specification, man pages, info pages, howtos, FAQs, etc.
  • Browse Internet sites for Java applets, code, and documentation.
1.4. The Software Development Process
  • Describe the nature of the software development process.
  • List and describe models and stages in the software development life cycle.
  • Describe software development activities such as project planning, resource management, analysis, specification, design, coding, testing, debugging, installing, training, supporting, and documenting.
  • Describe different roles involved in software development, including project managers, systems analysts, subject matter experts, programmers, technical writers, testers, and end users.
  • Write requirements and design specifications for functions and programs which include purpose, inputs and outputs (return values and results), scope (boundary conditions, assumptions and limitations), and algorithms.
  • Develop programs that are correct, robust/reliable, fast/efficient, concise/lean/elegant, consistent, portable, easy to use, and easy for other developers to read, reuse, extend and maintain; Evaluate the extent to which existing programs meet these goals.
  • Develop an approach to software development that is:
    • systematic, planned, methodical, consistent
    • structured, organised, hierarchical
    • logical, analytical, deductive, reasoned
    • evaluative, diagnostic, problem-solving
    • careful, precise, detail-oriented, accurate
    • cooperative, communicative, team-oriented
    • productive, minimalist, efficient, timely, cost-effective
    • reflective, meta-cognitive, process-oriented
1.5 Application to Scientific Problems
  • Identify areas of interest in applying programming to a chosen scientific field.
  • Use programming to solve simple problems in scientific fields, including computer science, mathematics, statistics and economics.
2. Basic Language Features
2.1. Variables and Types
  • identifiers and keywords
  • data types ([short|long] integer, floating point, double precision, long double, character, string, boolean) and the sizeof() operator
  • ASCII and EBCDIC character sets
  • constants and variables; const qualifier
  • enumeration types
  • declaration and assignment, lvalues and rvalues
  • Use valid, meaningful identifier names that connote usage.
  • Use named constants and variables instead of embedding magic numbers in code.
  • Convert between decimal, binary, octal and hexadecimal numbers.
  • Convert between decimal, exponential and scientific notation.
  • Convert between ASCII values and characters including escape sequences.
2.2. Operators and Expressions
  • Identify and explain operators (+ - * / % = == != <= >= < > += ++ && || ! & | () etc.)
  • Classify operators (as arithmetic, logical or relational, unary or binary, prefix, infix or postfix, increment or decrement)
  • type conversion using casts
  • Evaluate a given expression using a list of operators ordered by their precedence.
  • Apply DeMorgan's law to convert between AND statements and OR statements.
2.3. Statements and Comments
  • statements: simple, compound/block, null (...;, {...}, ;)
  • comments: C style, C++ style, Javadoc (/*...*/, //..., /**...*/)
  • Order statements correctly (preprocessor directives, named constants, main(), main function declarations, other executable statements, return value).
  • Use consistent, readable indentation, spacing and comments that help other programmers to understand code structure and purpose.
  • Generate automatic documentation using Javadoc.
2.4. Input and Output
  • Describe different input/output objects (input vs. output, character vs. byte, data vs. processing, object) and methods and the structure of the java.io package.
  • Perform file input and output using the command line and stream readers and writers.
  • Use redirection and pipes.
  • Create a menu-driven interface using standard I/O.
  • Create batch files and shell scripts to automate tasks.
  • Serialize objects.
2.5. Branching Features
  • selection/conditionals (if/else and switch/case statements, chained else)
  • iteration/repetition/looping (for, while and do..while statements, break and continue, nested loops)
  • Explain why statement labels, goto, break and continue should be kept to a minimum.
  • Convert between different methods of producing selection and iteration.
  • Validate input data.
2.6. Built-in Objects
  • Explain the relationship between variables, addresses, memory locations, pointers and references.
  • Use an array or vector to represent a sequence of items.
  • Use string manipulation and processing functions.
  • Use mathematical library functions (abs, sin/cos/ tan, sqrt/pow, log/log10, exp, random).
3. Procedural Features
  • Explain the advantages of modularity, procedural abstraction, encapsulation and reusability.
  • Explain the disadvantages of redundant copies of code.
  • Identify name, parameters and return value of a function.
  • Differentiate local and global variable scope, and identify the scope of a variable in a given program.
  • Explain why global variables are kept to a minimum.
  • Differentiate passing by reference and value.
  • Use header files and source code files.
  • Create and use function prototypes and definitions.
  • Given function specifications or code, specify inputs and outputs, pre- and post-conditions.
  • Implement a function given specifications of its inputs and outputs.
  • Create a main program to test a given function.
  • Use function overloading.
  • Use inline functions.
  • Pass variables by value, objects by reference.
  • Convert between iterative and recursive algorithms.
4. Object-Based and Object-Oriented Features
  • Differentiate procedural, object-based, object-oriented and generic programming.
  • Define and give real-world examples of class, object, attribute/field, method.
  • Differentiate instance and static (class) methods and fields.
  • Define class library, API and package and explain the use of the import declaration.
  • Differentiate method access control (public, private, protected and default/package).
  • Define interface, polymorphism, inheritance, overloading, overriding.
  • Define abstract class and method, final class and method, nested and inner class.
  • List attributes and methods of a class given its specifications or code.
  • Use existing classes in the Java standard library.
  • Create objects as instances of classes.
  • Define appropriate classes and class hierarchies to model existing objects, ideas, or entities.
  • List and perform steps to implement a class.
  • Put the features of a class definition in a consistent sequence.
  • Convert procedural code to object-oriented code.
  • Declare and use fields and methods with appropriate parameters, return type, and access control.
  • Use interfaces, polymorphism and inheritance.
  • Use method overloading and overriding.
5. Algorithms and Data Structures
  • Define abstract and user-defined data types.
  • Describe simple data structures (linked lists, stacks, queues).
  • Describe simple sorting algorithms (bubble, insertion, selection, merge).
  • Describe simple searching algorithms (sequential, binary).
  • Use an object to represent a compound data structure.
  • Implement a linked list, a stack and a queue.
  • Implement simple searching and sorting algorithms.
6. Graphics, GUIs, Events, Exceptions
  • Describe the use of containers and layout managers.
  • Describe graphical coordinates and RGB colours in Java.
  • Select an appropriate GUI component for a given I/O task.
  • Explain how the operating system handles events and exceptions.
  • Create a Java applet and embed in a simple HTML document.
  • Use two-dimensional graphic components, including shapes, colors and fonts.
  • Use GUI components from AWT and Swing including buttons, text components, combo boxes, dialog boxes and menus.
  • Use event-handlers to process mouse and keyboard input.
  • Handle exceptions using throw, catch and finally.
7. Internet and Database Features
  • Explain how Internet clients and servers communicate using protocols like HTTP and sockets.
  • Explain the structure of relational databases and SQL commands.
  • Send and receive data through sockets.
  • Create simple network client and server applications.
  • Communicate with web servers using HTTP commands like GET and POST.
  • Query and update a database using Java and SQL.