IB Computer Science Curriculum and Syllabus
IB Computer science requires an understanding of the fundamental concepts of computational thinking as well as knowledge of how computers and other digital devices operate. The Diploma Programme IB computer science course is engaging, accessible, inspiring and rigorous.
The exchange of information and ideas across national boundaries has been essential to the progress of the subject. This exchange is not a new phenomenon but it has accelerated in recent times with the development of information and communication technologies.
The development of solutions may be at a local, national or global scale and lies at the heart of the subject. These developments have revolutionized the way that people, and in particular the young, interact.
This IB Computer Science course:
- draws on a wide spectrum of knowledge
- enables and empowers innovation, exploration and the acquisition of further knowledge
- interacts with and influences cultures, society and how individuals and societies behave
- raises ethical issues
- is underpinned by computational thinking
There is no one scientific method of gaining knowledge or of finding explanations for the behaviour of the natural world. IB Computer science works through a variety of approaches to produce these explanations, but they all rely on data from observations and have a common underpinning rigour, whether using inductive or deductive reasoning.
The explanation may be in the form of a theory, sometimes requiring a model that contains elements not directly observable. Producing these theories often requires an imaginative, creative leap. Where such a predictive theoretical model is not possible, the explanation may consist of identifying a correlation between a factor and an outcome. This correlation may then give rise to a causal mechanism that can be experimentally tested, leading to an improved explanation. All these explanations require an understanding of the limitations of data, and the extent and limitations of our knowledge.
IB Computer Science Overall Expectations
IB Computer Science Diploma Programme computer science students should become aware of how computer scientists work and communicate with each other and with other stakeholders in the successful development and implementation of IT solutions.
- provide opportunities for study and creativity within a global context that will stimulate and challenge
- students developing the skills necessary for independent and lifelong learning
- provide a body of knowledge, methods and techniques that characterize computer science
- enable students to apply and use a body of knowledge, methods and techniques that characterize computer science
- demonstrate initiative in applying thinking skills critically to identify and resolve complex problems
- engender an awareness of the need for, and the value of, effective collaboration and communication in resolving complex problems
- develop logical and critical thinking as well as experimental, investigative and problem-solving skills
- develop and apply the students’ information and communication technology skills in the study of computer science to communicate information confidently and effectively
- raise awareness of the moral, ethical, social, economic and environmental implications of using science and technology
- develop an appreciation of the possibilities and limitations associated with continued developments in IT systems and computer science
- encourage an understanding of the relationships between scientific disciplines and the overarching nature of the scientific method.
Computational Thinking in IB Computer Science
Computational thinking is a problem-solving methodology that is applicable across a range of subject disciplines and underpins this course.
- thinking procedurally
- thinking logically
- thinking ahead
- thinking concurrently
- thinking abstractly
- thinking recursively
Learning Goals For IB Computer Science in Computational Thinking
By the end of this course IB Computer Science Students should be able to do the following
Thinking Procedurally
- Identify the procedure appropriate to solving a problem.
- Evaluate whether the order in which activities are undertaken will result in the required outcome.
- Explain the role of sub-procedures in solving a problem.
Thinking Logically
- Identify when decision-making is required in a specified situation.
- Identify the decisions required for the solution to a specified problem
- Identify the condition associated with a given decision in a specified problem.
- Explain the relationship between the decisions and conditions of a system
- Deduce logical rules for real-world situations.
Thinking Ahead
- Identify the inputs and outputs required in a solution.
- Identify pre-planning in a suggested problem and solution.
- Explain the need for pre-conditions when executing an algorithm.
- Outline the pre- and post-conditions to a specified problem.
- Identify exceptions that need to be considered in a specified problem solution
Thinking Concurrently
- Identify the parts of a solution that could be implemented concurrently
- Describe how concurrent processing can be used to solve a problem.
- Evaluate the decision to use concurrent processing in solving a problem
Thinking Abstractly
- Identify examples of abstraction
- Explain why abstraction is required in the derivation of computational solutions for a specified situation.
- Construct an abstraction from a specified situation.
- Distinguish between a real-world entity and its abstraction.
Developing Algorithms
- Describe the characteristics of standard algorithms on linear arrays.
- Outline the standard operations of collections.
- Discuss an algorithm to solve a specific problem.
- Analyze an algorithm presented as a flow chart.
- Analyze an algorithm presented as pseudocode.
- Construct pseudocode to represent an algorithm.
- Suggest suitable algorithms to solve a specific problem.
- Deduce the efficiency of an algorithm in the context of its use.
- Determine the number of times a step in an algorithm will be performed for given input data.
Writing Code
- State the fundamental operations of a computer.
- Distinguish between fundamental and compound operations of a computer.
- Explain the essential features of a computer language.
- Explain the need for higher level languages.
- Outline the need for a translation process from a higher level language
to machine executable code. - Define the terms: variable, constant, operator, object.
- Define the operators =, ≠, <, <=, >, >=, mod, div.
- Analyse the use of variables, constants and operators in algorithms
- Construct algorithms using loops, branching.
- Describe the characteristics and applications of a collection.
- Construct algorithms using the access methods of a collection.
- Discuss the need for sub-programmes and collections within programmed solutions.
- Construct algorithms using predefined sub-programmes, onedimensional arrays and/or collections.
Thinking Recursively
- Identify a situation that requires the use of recursive thinking.
- Identify recursive thinking in a specified problem solution.
- Trace a recursive algorithm to express a solution to a problem.
Abstract Data Structures
- Describe the characteristics of a two dimensional array
- Construct algorithms using two dimensional arrays.
- Describe the characteristics and applications of a stack.
- Construct algorithms using the access methods of a stack
- Describe the characteristics and applications of a queue.
- Construct algorithms using the access methods of a queue.
- Explain the use of arrays as static stacks and queues.
Linked Lists
- Describe the features and characteristics of a dynamic data structure.
- Describe how linked lists operate logically
- Sketch linked lists (single, double and circular).
Trees
- Describe how trees operate logically (both binary and non-binary).
- Define the terms: parent, left-child, right-child, subtree, root and leaf.
- State the result of inorder, postorder and preorder tree traversal.
- Sketch binary trees.
Object Oriented Programming
- Outline the general nature of an object.
- Distinguish between an object (definition, template or class) and instantiation
- Construct unified modelling language (UML) diagrams to represent object designs.
- Interpret UML diagrams.
- Describe the process of decomposition into several related objects.
- Describe the relationships between objects for a given problem.
- Outline the need to reduce dependencies between objects in a given problem
- Construct related objects for a given problem.
- Explain the need for different data types to represent data items.
- Describe how data items can be passed to and from actions as parameters.
Features of Object Oriented Programming
- Define the term encapsulation.
- Define the term inheritance.
- Define the term polymorphism
- Explain the advantages of encapsulation.
- Explain the advantages of inheritance.
- Explain the advantages of polymorphism.
- Describe the advantages of libraries of objects
- Describe the disadvantages of OOP.
- Discuss the use of programming teams.
- Explain the advantages of modularity in program development.
Program Development
- Define the terms: class, identifier, primitive, instance variable, parameter variable, local variable.
- Define the terms: method, accessor, mutator, constructor, signature, return value
- Define the terms: private, protected, public, extends, static.
- Describe the uses of the primitive data types and the reference class string.
- Construct code examples related to selection statements.
- Construct code examples related to repetition statements.
- Construct code examples related to static arrays.
- Discuss the features of modern programming languages that enable internationalization.
- Discuss the ethical and moral obligations of programmers.
Advanced Program Development
- Define the term recursion.
- Describe the application of recursive algorithms.
- Construct algorithms that use recursion
- Trace recursive algorithms
- Define the term object reference
- Construct algorithms that use reference mechanisms.
- Identify the features of the abstract data type (ADT) list.
- Describe applications of lists.
- Construct algorithms using a static implementation of a list.
- Construct list algorithms using object references
- Construct algorithms using the standard library collections included in JETS.
- Trace algorithms using the implementations
- Explain the advantages of using library collections.
- Outline the features of ADT’s stack ,queue and binary tree.
- Explain the importance of style and naming conventions in code.
IB Computer Science Unit 1
Lessons For Unit 1
- Installing Java
- Using an Integrated Development Environment
- Create a Java Program
- Print text to a Text Only Console
- How data is stored in a computer memory and how to access that data in a program
- How to get keyboard input from the user of your program from the text console
- How to output data back to the console
- Manipulating data using mathematical operators and functions
- Outline program structure using pseudocode
- Solve common mathematical problems with computer software.
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
IB Computer Science Unit 2
Lessons For Unit 2
- Use Simple Math to Solve Problems
- Think Sequentially about how a computer executes code
- Use Simple Math to Solve Problems
- Think Sequentially about how a computer executes code
- Use the Input Processing Output Method of Problem Solving
- Use the built in GUI Builder to design a graphical interface for your computer programs
- Add events to GUI elements
- Get text input from the GUI and output processed data to the GUI
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
IB Computer Science Unit 3
Lessons for Unit 3
- Writing programs that use if – else structures using numerical comparisons
- Write programs that use if – else structures that use more than 1 comparison
- Write programs that can compare Strings together
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
- Understanding how computer programs can repeat tasks
- Writing programs that use while loops and for loops
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
IB Computer Science Unit 4
Lessons For Unit 4
- Writing Modular Programs by creating your own methods
- Writing programs that use one dimensional arrays of primitive data types
- How to use String and Character values in a program
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
- Writing a program that reads information from a text file
- Writing a program that writes and appends information to a text file
- How to use Tokens and Delimiters to separate parts Strings into individual pieces
- Methods used with StringTokenizer Class
- How to use methods with array data structures
- Passing By Reference
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
IB Computer Science Unit 5
Lessons for Unit 5
- Using classes to create data objects
- Manipulate arrays of objects
- Define Encapsulation of Data
- Write classes that encapsulate data and methods
- Use Classes to solve problems
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
- Load Tabular Data into a computer program
- Manipulate the rows and columns of a 2D data structure
- Create and modify data in an ArrayList
- Stack and Queue Data Structures
- Linked List Data Structures
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
IB Computer Science Unit 6
Lessons for Unit 6
- Learn about child and parent relationships between classes
- Define Subclasses
- Understand the concepts of Polymorphism
- Learn how to override parent class methods
- Write overloaded methods within a class
- Understanding Basic Sorting Algorithms such as insertion, selection, bubble
- Learn about linear and binary search algorithms
- Compare Iterative vs Recursive Algorithms
- Trace Recursive algorithms
- Analyze and code a quick sort algorithm
- Practice Problem Solving, creating algorithms, and writing code to solve those problems
IB Computer Science Assessment and Evaluation
Assessment is an integral part of teaching and learning. The most important aims of assessment in the Diploma Programme are that it should support curricular goals and encourage appropriate student learning. Both external and internal assessment are used in the Diploma Programme. IB Computer Science examiners mark work produced for external assessment, while work produced for internal assessment is marked by teachers
and externally moderated by the IB.
The Diploma Programme primarily focuses on summative assessment designed to record student achievement at, or towards the end of, the course of study. However, many of the assessment instruments can also be used formatively during the course of teaching and learning, and teachers are encouraged to do this. A comprehensive assessment plan is viewed as being integral with teaching, learning and course organization. For further information, see the IB Computer Science Programme standards and practices document.
The approach to assessment used by the IB is criterion-related, not norm-referenced. This approach to assessment judges students’ work by their performance in relation to identified levels of attainment, and not in relation to the work of other students. For further information on assessment within the Diploma Programme please refer to the publication Diploma Programme assessment: Principles and practice.
Assessment criteria are used when the assessment task is open-ended. Each criterion concentrates on a particular skill that students are expected to demonstrate. An assessment objective describes what students should be able to do and assessment criteria describe how well they should be able to do it. Using assessment criteria allows discrimination between different answers and encourages a variety of responses.
Each criterion comprises a set of hierarchically ordered level descriptors. Each level descriptor is worth one or more marks. Each criterion is applied independently using a best-fit model. The maximum marks for each criterion may differ according to the criterion’s importance. The marks awarded for each criterion are added together to give the total mark for the piece of work.
Standard Level
IB Computer Science External assessment (2 hours 30 minutes)
- Paper 1 (1 hour 30 minutes)
- Paper 1 is an examination paper consisting of two compulsory sections.
- Section A (30 minutes approximately) consists of several compulsory short answer questions. The maximum mark for this section is 25.
- Section B (60 minutes approximately) consists of three compulsory structured questions. The maximum mark for this section is 45.
- Paper 1 is an examination paper consisting of two compulsory sections.
- Paper 2 (1 hour)
- Paper 2 is an examination paper linked to the option studied.
- The paper consists of between two and five compulsory questions.
IB Computer Science Internal assessment (40 hours)
This component is internally assessed by the teacher and externally moderated by
the IB at the end of the course.
Solution (30 hours)
- The development of a computational solution.
- Students must produce:
- A cover page that follows the prescribed format
- a product
- supporting documentation (word limit 2,000 words).
(34 marks)
Group 4 project (10 hours)
- To be assessed using the criterion Personal skills.
Higher Level
IB Computer Science External assessment (4 hours 30 minutes)
- Paper 1 (2 hour 10 minutes)
- Paper 1 is an examination paper consisting of two compulsory sections.
- Section A (30 minutes approximately) consists of several compulsory short answer questions. The maximum mark for this section is 25.
- Section B (60 minutes approximately) consists of three compulsory structured questions. The maximum mark for this section is 45.
- Paper 1 is an examination paper consisting of two compulsory sections.
- Paper 2 (1 hour 20 minutes)
- Paper 2 is an examination paper linked to the option studied.
- The paper consists of between three and seven compulsory questions.
The SL/HL core questions are common and worth 45 marks, HL extension is worth
20 marks.
Paper 3 (1 hour)
- Paper 3 is an examination paper of 1 hour consisting of four compulsory questions based on a pre-seen case study
IB Computer Science Internal assessment (40 hours)
This component is internally assessed by the teacher and externally moderated by
the IB at the end of the course.
Solution (30 hours)
- The development of a computational solution.
- Students must produce:
- A cover page that follows the prescribed format
- a product
- supporting documentation (word limit 2,000 words).
(34 marks)
Group 4 project (10 hours)
- To be assessed using the criterion Personal skills.
