DP CompSci: Syllabus

Unit 1: Systems fundamentals

Unit 1.1 Systems in organisations

System planning & installation

1.1.1 Identify the context for which a new system is planned.

  • The extent and limitations of a new system should be appreciated.
  • Organizational issues related to the installation of new systems such as user roles, underlying technologies.

1.1.2 Describe the need for change management.

  • Students should understand there are a number of factors that need to be managed to ensure change is successful.
  • The way that change is managed can have significant effects on employers and employees.

1.1.3 Outline compatibility issues resulting from situations including legacy systems or business mergers.

  • When organizations interact, particularly on an international basis, there may be issues of software compatibility and language differences.

1.1.4 Compare the implementation of systems using a client’s hardware with hosting systems remotely.

  • The benefits and drawbacks of SaaS (Software-as-a-Service) should be considered.
  • The remote host may be in a different time zone and this can have significant effects on end-users.

1.1.5 Evaluate alternative installation processes.

  • Students should be aware of the methods of implementation/conversion.
  • Parallel running, pilot running, direct changeover and phased conversion.
  • Training issues may require organizations to restructure their workforce.

1.1.6 Discuss problems that may arise as a part of data migration.

  • These include incompatible file formats, data structures, validation rules, incomplete data transfer and international conventions on dates, currencies and character sets.

1.1.7 Suggest various types of testing.

  • The crucial importance of testing at all stages of implementation should be emphasized, with the stages clearly defined.
  • Types of testing can include: user acceptance testing, debugging, beta testing.
  • Students should be aware that there are programs that can test other programs, thereby automating parts of the testing process and reducing costs.
  • Inadequate testing can reduce employee productivity and lead to end-user dissatisfaction.

User focus

1.1.8 Describe the importance of user documentation.

  • The quality of user documentation can affect the rate of implementation of the new system.

1.1.9 Evaluate different methods of providing user documentation.

  • Examples should include methods such as: help files, online support and printed manuals.
  • The quality of user documentation can affect the rate of implementation of the new system.

1.1.10 Evaluate different methods of delivering user training.

  • Examples should include self-instruction, formal classes, remote/online training.
  • The quality of the delivery of user training can affect the rate of implementation of the new system.

System backup

1.1.11 Identify a range of causes of data loss.

  • Causes include malicious activities and natural disasters.
  • Malicious activity may be a result of activities by employees within the organization or intruders.

1.1.12 Outline the consequences of data loss in a specified situation.

  • Loss of medical records, cancellation of a hotel reservation without the knowledge of the traveller.

1.1.13 Describe a range of methods that can be used to prevent data loss.

  • These should include failover systems, redundancy, removable media, offsite/online storage.

Software deployment

1.1.14 Describe strategies for managing releases and updates.

  • Students should be aware of a variety of ways in which updates and patches are made available and deployed. This includes automatic updates received on a regular basis online.
  • Performance issues related to the inability to install updates may hinder end-users and reduce compatibility between systems in geographically diverse locations.

Unit 1.2 System design basics

Components of a computer system

1.2.1 Define the terms: hardware, software, peripheral, network, human resources.

1.2.2 Describe the roles that a computer can take in a networked world.

  • Roles include client, server, email server, DNS server, router and firewall.

1.2.3 Discuss the social and ethical issues associated with a networked world.

  • Develop an appreciation of the social and ethical issues associated with continued developments in computer systems.

System design and analysis

1.2.4 Identify the relevant stakeholders when planning a new system.

  • The role of the end-user must be considered when planning a new system.
  • Who is a relevant stakeholder?
  • TOK Utilitarianism, the greatest good for the greatest number. The means justify the ends.

1.2.5 Describe methods of obtaining requirements from stakeholders.

  • Including surveys, interviews, direct observations.
  • The need for effective collaboration to obtain appropriate information from stakeholders.
  • The question of privacy for stakeholders.

1.2.6 Describe appropriate techniques for gathering the information needed to arrive at a workable solution.

  • Examining current systems, competing products, organizational capabilities, literature searches.
  • Intellectual property.

1.2.7 Construct suitable representations to illustrate system requirements.

  • Examples include: system flow charts, data flow diagrams, structure chart.
  • UML is not required.
  • LINK Flow chart symbols, flow charts and pseudocode.

1.2.8 Describe the purpose of prototypes to demonstrate the proposed system to the client.

  • The need to effectively collaborate to gather appropriate information to resolve complex problems.
  • To develop logical and critical thinking to develop proposed systems.

1.2.9 Discuss the importance of iteration during the design process.

  • MYP Design cycle.

1.2.10 Explain the possible consequences of failing to involve the end-user in the design process.

  • The failure to involve the end-user may lead to software that is not suitable for its intended use, which may have adverse effects on user productivity.
  • The need for effective collaboration and communication between the client, developer and end-user.

1.2.11 Discuss the social and ethical issues associated with the introduction of new IT systems.

  • Develop an appreciation of the social and ethical issues associated with continued developments in specified computer systems.

Human interaction with the system

1.2.12 Define the term usability.

  • This includes ergonomics and accessibility.

1.2.13 Identify a range of usability problems with commonly used digital devices.

  • Students should be aware of usability issues in a range of devices including PCs, digital cameras, cell phones, games consoles, MP3 players and other commonly used digital devices.

1.2.14 Identify methods that can be used to improve the accessibility of systems.

  • Examples include touch screen, voice recognition, text-to-speech, Braille keyboard.

1.2.15 Identify a range of usability problems that can occur in a system.

  • These should be related to the systems.
  • Systems include ticketing, online payroll, scheduling, voice recognition, systems that provide feedback.

1.2.16 Discuss the moral, ethical, social, economic and environmental implications of the interaction between humans and machines.

  • Raise awareness of the moral, ethical, social, economic and environmental implications of using science and technology.

Unit 2: Computer architecture

Computer architecture

2.1.1 Outline the architecture of the central processing unit (CPU) and the functions of the arithmetic logic unit (ALU) and the control unit (CU) and the registers within the CPU.

  • Students should be able to reproduce a block diagram showing the relationship between the elements of the CPU, input and output and storage. The memory address register (MAR) and memory data register (MDR) are the only ones that need to be included.

2.1.2 Describe primary memory.

  • Distinguish between random access memory (RAM) and read-only memory (ROM), and their use in primary memory.

2.1.3 Explain the use of cache memory.

  • Students should be able to explain the effect of cache memory in speeding up the system as well as being able to explain how it is used.

2.1.4 Explain the machine instruction cycle.

  • This should include the role of data bus and address bus.

Secondary memory

2.1.5 Identify the need for persistent storage.

  • Persistent storage is needed to store data in a non-volatile device during and after the running of a program.
  • LINK Consequences of data loss.
  • TOK If there are no consequences of data loss, why is it stored.
  • TOK There is no such thing as persistent storage.
  • AIM 9 An appreciation of the issues related to both the ever increasing amount of data and a need to retain it.

Operating systems and application software

2.1.6 Describe the main functions of an operating system.

  • This is confined to a single-user operating system. Technical details are not needed. For example, memory management should be described but how this is handled in a multitasking environment is not expected.

2.1.7 Outline the use of a range of application software.

  • Application software should include word processors, spreadsheets, database management systems, email, web browsers, computer-aided design (CAD) and graphic processing software.

2.1.8 Identify common features of applications.

  • Including toolbars, menus, dialogue boxes, graphical user interface (GUI) components.
  • Students should understand that some features are provided by the application software and some by the operating system.
  • S/E This improves usability for a wide range of users.
  • AIM 9 An appreciation of the improvements associated with developments in application software.

Binary representation

2.1.9 Define the terms: bit, byte, binary, denary/decimal, hexadecimal.

2.1.10 Outline the way in which data is represented in the computer.

  • To include strings, integers, characters and colours. This should include considering the space taken by data, for instance the relation between the hexadecimal representation of colours and the number of colours available.
  • TOK, INT Does binary represent an example of a lingua franca?
  • S/E, INT Comparing the number of characters needed in the Latin alphabet with those in Arabic and Asian languages to understand the need for Unicode.

Simple logic gates

2.1.11 Define the Boolean operators: AND, OR, NOT, NAND, NOR and XOR.

  • LINK Introduction to programming, approved notation sheet.

2.1.12 Construct truth tables using the above operators.

  • For example, Maria won’t go to school if it is cold and raining or she has not done her homework.
  • Not more than three inputs are used.
  • LINK Thinking logically.
  • TOK Reason as a way of knowing.

2.1.13 Construct a logic diagram using AND, OR, NOT, NAND, NOR and XOR gates.

  • Problems will be limited to an output dependent on no more than three inputs.

Unit 3: Networks

Network fundamentals

3.1.1 Identify different types of networks.

  • Examples include local area network (LAN), virtual local area network (VLAN), wide area network (WAN), storage area network (SAN), wireless local area network (WLAN), internet, extranet, virtual private network (VPN), personal area network (PAN), peer-to-peer (P2P).
  • S/E, INT Globalization has been accelerated by the technical advances linked to network development.

3.1.2 Outline the importance of standards in the construction of networks.

  • INT Standards enable compatibility through a common “language” internationally.

3.1.3 Describe how communication over networks is broken down into different layers.

  • Awareness of the OSI seven layer model is required, but an understanding of the functioning of each layer is not.

3.1.4 Identify the technologies required to provide a VPN.

3.1.5 Evaluate the use of a VPN.

  • S/E, AIM 9 The use of a VPN has led to changes in working patterns.

Data transmission

3.1.6 Define the terms: protocol, data packet.

3.1.7 Explain why protocols are necessary.

  • Including data integrity, flow control, deadlock, congestion, error checking.

3.1.8 Explain why the speed of data transmission across a network can vary.

3.1.9 Explain why compression of data is often necessary when transmitting across a network.

  • S/E, INT Compression has enabled information to be disseminated more rapidly.

3.1.10 Outline the characteristics of different transmission media.

  • Characteristics include: speed, reliability, cost and security.
  • Transmission media include: metal conductor, fibre optic, wireless.

3.1.11 Explain how data is transmitted by packet switching.

Wireless networking

3.1.12 Outline the advantages and disadvantages of wireless networks.

  • S/E Wireless networks have led to changes in working patterns, social activities and raised health issues.

3.1.13 Describe the hardware and software components of a wireless network.

3.1.14 Describe the characteristics of wireless networks.

  • Include: WiFi; Worldwide Interoperability for Microwave Access (WiMAX); 3G mobile; future networks.
  • S/E, INT Connectivity between different locations.

3.1.15 Describe the different methods of network security.

  • Include encryption types, userID, trusted media access control (MAC) addresses.
  • S/E Wireless networks have led to concerns about the security of the user’s data.

3.1.16 Evaluate the advantages and disadvantages of each method of network security.

Unit 4.1: Computational thinking principles

Thinking procedurally

4.1.1 Identify the procedure appropriate to solving a problem.

  • This includes identifying the steps and putting them in the correct order. Such as recipes, block-arrow-block-arrow.
  • LINK Connecting computational thinking and program design, introduction to programming.

4.1.2 Evaluate whether the order in which activities are undertaken will result in the required outcome.

  • Links to problems presented to the student in other areas of the syllabus.
  • LINK Thinking ahead, thinking concurrently. Connecting computational thinking and program design, introduction to programming.
  • MYP Technology, step-by-step instructions.

4.1.3 Explain the role of sub-procedures in solving a problem.

  • Constructing procedures that can then be referred to by their identifier.
  • LINK Abstraction, connecting computational thinking and program design, introduction to programming.

Thinking logically

4.1.4 Identify when decision-making is required in a specified situation.

  • Links to procedural thinking—alternative procedures.
  • TOK Reasoning as a form of decision-making.
  • LINK Connecting computational thinking and program design, introduction to programming.

4.1.5 Identify the decisions required for the solution to a specified problem.

  • Different actions are taken based on conditions.
  • LINK Connecting computational thinking and program design, introduction to programming.
  • AIM 4 Applying thinking skills to identify and resolve a specified complex problem.

4.1.6 Identify the condition associated with a given decision in a specified problem.

  • Testing conditions, iteration. Identifying and constructing the conditions—AND, OR, NOT relationships—Boolean tests.
  • LINK Connecting computational thinking and program design, introduction to programming.

4.1.7 Explain the relationship between the decisions and conditions of a system.

  • IF … THEN … ELSE
  • LINK Connecting computational thinking and program design, introduction to programming.

4.1.8 Deduce logical rules for real-world situations.

  • LINK Connecting computational thinking and program design, introduction to programming.

Thinking ahead

4.1.9 Identify the inputs and outputs required in a solution.

4.1.10 Identify pre-planning in a suggested problem and solution.

  • Gantt charts.
  • Pre-ordering. Pre-heating an oven. Home/locker/knapsack.
  • Caching/pre-fetching. Building libraries of pre-formed elements for future use.
  • LINK Thinking procedurally, thinking concurrently. Connecting computational thinking and program design, introduction to programming.

4.1.11 Explain the need for pre-conditions when executing an algorithm.

4.1.12 Outline the pre- and post-conditions to a specified problem.

  • For example, cooking a dish for a meal.
  • All ingredients available before starting to cook.
  • A place to eat the food.

4.1.13 Identify exceptions that need to be considered in a specified problem solution.

  • For example, identify the pre-conditions for calculating the end-of-year bonus when not all employees have worked for the company for the whole year.
  • LINK Connecting computational thinking and program design, introduction to programming.

Thinking concurrently

4.1.14 Identify the parts of a solution that could be implemented concurrently.

  • Could include computer systems or real-life situations.
  • LINK Thinking ahead, thinking procedurally. Connecting computational thinking and program design, introduction to programming.

4.1.15 Describe how concurrent processing can be used to solve a problem.

  • For example, building a house, production lines, division of labour.
  • Students will not be expected to construct a flow chart or pseudocode related to concurrent processing.

4.1.16 Evaluate the decision to use concurrent processing in solving a problem.

  • LINK Thinking ahead, thinking procedurally. Connecting computational thinking and program design, introduction to programming.

Thinking abstractly

4.1.17 Identify examples of abstraction.

  • Selecting the pieces of information that are relevant to solving the problem.
  • LINK Thinking ahead.

4.1.18 Explain why abstraction is required in the derivation of computational solutions for a specified situation.

  • Students should be aware of the concept of objects, for example, the use of collections as objects in the design of algorithms.
  • LINK
  • Databases: tables, queries
  • Modelling and simulation: an abstraction of reality
  • OOP: classes, sub-classes
  • Web science: distributed applications

4.1.19 Construct an abstraction from a specified situation.

  • There is no need to use code.
  • Levels of abstraction through successive decomposition.
  • A school can be decomposed into faculties. A faculty can be decomposed into departments.
  • LINK Thinking ahead, thinking procedurally. Connecting computational thinking and program design, introduction to programming.

4.1.20 Distinguish between a real-world entity and its abstraction.

  • TOK The map as an abstraction of the territory.

Unit 4.2: Computational thinking program design

4.2.1 Describe the characteristics of standard algorithms on linear arrays.

  • These are: sequential search, binary search, bubble sort, selection sort.

4.2.2 Outline the standard operations of collections.

  • These are: addition and retrieval of data.

4.2.3 Discuss an algorithm to solve a specific problem.

  • Students should be expected to discuss the differences between algorithms, including both standard and novel algorithms. For example, discussing the advantages and disadvantages of using a binary search as opposed to a sequential search.

4.2.4 Analyse an algorithm presented as a flow chart.

  • Examination questions may involve variables, calculations, simple and nested loops, simple conditionals and multiple or nested conditionals.
  • This would include tracing an algorithm as well as assessing its correctness.
  • Students will not be expected to construct a flow chart to represent an algorithm in an externally assessed component.
  • MYP Mathematics: using flow charts to solve problems in real-life contexts, patterns and sequences, logic, algorithms.
  • MYP Technology: design cycle (inputs, processes, outputs, feedback, iteration).

4.2.5 Analyse an algorithm presented as pseudocode.

  • Examination questions may involve variables, calculations, simple and nested loops, simple conditionals and multiple or nested conditionals.
  • This would include tracing an algorithm as well as assessing its correctness.
  • MYP Mathematics: using flow charts to solve problems in real-life contexts, patterns and sequences, logic, algorithms.
  • MYP Technology: design cycle (inputs, processes, outputs, feedback, iteration).

4.2.6 Construct pseudocode to represent an algorithm.

  • MYP Mathematics: using flow charts to solve problems in real-life contexts, patterns and sequences, logic, algorithms.
  • MYP Technology: design cycle (inputs, processes, outputs, feedback, iteration).
  • AIM 4 Demonstrate thinking skills to represent a possible solution to a specified complex problem.

4.2.7 Suggest suitable algorithms to solve a specific problem.

  • Suitable algorithms may include both standard algorithms and novel algorithms. Suitable may include considerations of efficiency, correctness, reliability and flexibility. Students are expected to suggest algorithms that will actually solve the problem successfully.
  • LINK General principles of computational thinking, introduction to programming.

4.2.8 Deduce the efficiency of an algorithm in the context of its use.

  • Students should understand and explain the difference in efficiency between a single loop, nested loops, a loop that ends when a condition is met or questions of similar complexity.
  • Students should also be able to suggest changes in an algorithm that would improve efficiency, for example, using a flag to stop a search immediately when an item is found, rather than continuing the search through the entire list.

4.2.9 Determine the number of times a step in an algorithm will be performed for given input data.

  • Examination questions will involve specific algorithms (in pseudocode/flow charts), and students may be expected to give an actual number (or range of numbers) of iterations that a step will execute.

Unit 4.3: Introduction to programming

Nature of programming languages

4.3.1 State the fundamental operations of a computer.

  • These include: add, compare, retrieve and store data.
  • Complex capabilities are composed of very large numbers of very simple operations.

4.3.2 Distinguish between fundamental and compound operations of a computer.

  • For example, “find the largest” is a compound operation.

4.3.3 Explain the essential features of a computer language.

  • For example, fixed vocabulary, unambiguous meaning, consistent grammar and syntax.
  • TOK Language and meaning.

4.3.4 Explain the need for higher level languages.

  • For example, as the human needs for computer systems have expanded it is necessary to abstract from the basic operations of the computer. It would take far too long to write the type of systems needed today in machine code.

4.3.5 Outline the need for a translation process from a higher level language to machine executable code.

  • For example, compiler, interpreter, virtual machine.

Use of programming languages

4.3.6 Define the terms: variable, constant, operator, object.

4.3.7 Define the operators =, ≠, <, <=, >, >=, mod, div.

  • LINK Approved notation sheet.

4.3.8 Analyse the use of variables, constants and operators in algorithms.

  • For example, identify and justify the use of a constant as opposed to a variable in a given situation.
  • MYP Mathematics: forms of numbers, algebra—patterns and sequences, logic, algorithms.

4.3.9 Construct algorithms using loops, branching.

  • Teachers must ensure algorithms use the symbols from the approved notation sheet.
  • LINK Approved notation sheet.
  • MYP Mathematics: using flow charts to solve problems in real-life contexts, logic, algorithms
  • MYP Technology: design cycle (inputs, processes, outputs, feedback, iteration).
  • LINK Connecting computational thinking and program design.

4.3.10 Describe the characteristics and applications of a collection.

  • Characteristics:
  • Contains similar elements.
  • LINK HL extension, recursive thinking.
  • LINK General principles of computational thinking, connecting computational thinking and program design.

4.3.11 Construct algorithms using the access methods of a collection.

  • LINK Connecting computational thinking and program design.

4.3.12 Discuss the need for sub-programmes and collections within programmed solutions.

  • Show an understanding of the usefulness of reusable code and program organization for the individual programmer, team members and future maintenance.
  • LINK General principles of computational thinking, connecting computational thinking and program design.
  • MYP Technology: use of software such as Alice.

4.3.13 Construct algorithms using pre-defined sub-programmes, one-dimensional arrays and/or collections.

  • MYP Mathematics: using flow charts to solve problems in real-life contexts, logic, algorithms.
  • MYP Technology: design cycle (inputs, processes, outputs, feedback, iteration); use of software such as Alice.
  • Students will only be required to analyse flow charts in the externally assessed components.
  • Students will be expected to write and analyse pseudocode in the externally assessed components.
  • S/E, AIM 8 Appreciate the implications of using available code from sources such as online forums.
  • LINK Connecting computational thinking and program design.

Unit 5: Abstract data structures (HL)

Thinking recursively

5.1.1 Identify a situation that requires the use of recursive thinking.

  • Suggested practical activity: snowflakes and fractals, towers of Hanoi.

5.1.2 Identify recursive thinking in a specified problem solution.

  • LINK Binary trees.

5.1.3 Trace a recursive algorithm to express a solution to a problem.

  • Students will be required to state the output of the recursive algorithm. For example, trees.
  • LINK Binary trees.

Abstract data structures

5.1.4 Describe the characteristics of a two-dimensional array.

  • LINK One-dimensional arrays and basic algorithms.

5.1.5 Construct algorithms using two-dimensional arrays.

  • LINK Pseudocode information.

5.1.6 Describe the characteristics and applications of a stack.

  • Characteristics:
  • Last in, first out (LIFO).
  • Examples of the applications of stacks may include running recursive processes, return memory addresses.
  • LINK Recursive thinking; connecting computational thinking and program design.

5.1.7 Construct algorithms using the access methods of a stack.

  • Access methods:
  • push
  • pop
  • isEmpty.
  • LINK Connecting computational thinking and program design.

5.1.8 Describe the characteristics and applications of a queue.

  • Characteristics:
  • First in, first out (FIFO).
  • Examples of the applications of queues may include print queues and the computer modelling of physical queues (eg supermarket checkouts).
  • Both linear and circular implementation of a queue are required.
  • LINK Connecting computational thinking and program design.

5.1.9 Construct algorithms using the access methods of a queue.

  • Access methods:
  • enqueue
  • dequeue
  • isEmpty.
  • LINK Connecting computational thinking and program design.

5.1.10 Explain the use of arrays as static stacks and queues.

  • Students should be able to explain push and pop operations, and test on empty/full stack.
  • Students should be able to explain enqueue and dequeue operations, and test on empty/full queue.

Linked lists

5.1.11 Describe the features and characteristics of a dynamic data structure.

  • Students should understand the concepts of nodes and pointer.

5.1.12 Describe how linked lists operate logically.

  • LINK Logical thinking.

5.1.13 Sketch linked lists (single, double and circular).

  • Students should be able to sketch diagrams illustrating: adding a data item to linked list, deleting specified data item, modifying the data held in the linked list, searching for a given data item.

Trees

5.1.14 Describe how trees operate logically (both binary and non-binary).

  • LINK Recursive thinking.

5.1.15 Define the terms: parent, left-child, right-child, subtree, root and leaf.

  • These definitions only apply to a binary tree.

5.1.16 State the result of inorder, postorder and preorder tree traversal.

5.1.17 Sketch binary trees.

  • Students should be able to sketch diagrams showing the resulting binary tree after adding a new data item, adding one or more new nodes, and/or removing one or more nodes.

Applications

5.1.18 Define the term dynamic data structure.

5.1.19 Compare the use of static and dynamic data structures.

  • LINK One-dimensional arrays.

5.1.20 Suggest a suitable structure for a given situation.

Unit 6: Resource management (HL)

System resources

6.1.1 Identify the resources that need to be managed within a computer system.

  • Resources include: primary memory, secondary storage, processor speed, bandwidth, screen resolution, disk storage, sound processor, graphics processor, cache, network connectivity.

6.1.2 Evaluate the resources available in a variety of computer systems.

  • These should include: mainframes, servers, PCs, sub-laptops, as well as personal digital devices such as cell phones, PDAs and digital cameras.
  • AIM 9 Develop an appreciation of the issues linked to resource availability with continued developments in computer systems.

6.1.3 Identify the limitations of a range of resources in a specified computer system.

  • For example, single processor computers may not be able to render 3D graphics effectively.

6.1.4 Describe the possible problems resulting from the limitations in the resources in a computer system.

  • For example, user time wasted if the primary memory is too small or processor speed inadequate.
  • Multi-access and multi-programming environments should be considered as well as single-user systems.

Role of the operating system

6.1.5 Explain the role of the operating system in terms of managing memory, peripherals and hardware interfaces.

  • For example, allocating storage and keeping track of programs in memory, swapping between programs on time-slicing, priority or when one is waiting for input.

6.1.7 Outline OS resource management techniques: scheduling, policies, multitasking, virtual memory, paging, interrupt, polling.

  • Technical details as to how these are carried out will not be required, but it is expected that students will be familiar with these techniques and understand when and why they are used.

6.1.8 Discuss the advantages of producing a dedicated operating system for a device.

  • Advantages related to size, speed and customization should be considered.
  • For example, using a dedicated operating system for a cell phone rather than using a pre-existing operating system.
    S/E Issue of proprietary software.

6.1.9 Outline how an operating system hides the complexity of the hardware from users and applications.

  • Students should be aware of a range of examples where operating systems virtualize real devices, such as drive letters, virtual memory, input devices, the Java virtual machine.
  • INT Issue of localization causing compatibility problems between systems in different countries.

Unit 7: Control systems (HL)

Centralised control systems

7.1.1 Discuss a range of control systems.

  • A variety of control systems should be examined such as automatic doors, heating systems, taxi meters, elevators, washing machines, process control, device drivers, domestic robots, GPS systems, traffic lights and other common devices.
  • Technical knowledge of specific systems is not expected but students should be able to analyse a specified system.
  • AIM 9 Develop an appreciation of the possibilities for control systems with developments in computer systems.

7.1.2 Outline the uses of microprocessors and sensor input in control systems.

  • These should be related to the examples suggested above.

7.1.3 Evaluate different input devices for the collection of data in specified situations.

  • Scenarios will be based on familiar situations to students.

7.1.4 Explain the relationship between a sensor, the processor and an output transducer.

  • Technical hardware details are not expected.

7.1.5 Describe the role of feedback in a control system.

  • LINK Connecting computational thinking and program design.

7.1.6 Discuss the social impacts and ethical considerations associated with the use of embedded systems.

  • S/E For example, tagging prisoners, surveillance, CCTV, improved safety systems.

Distributed control systems

7.1.7 Compare a centrally controlled system with a distributed system.

  • Technical hardware details are not expected.

7.1.8 Outline the role of autonomous agents acting within a larger system.

  • Technical hardware details are not expected.

Unit D1: OOP concepts

D.1.1 Outline the general nature of an object.

  • An object as an abstract entity and its components—data and actions.
  • Familiar examples from different domains might be people, cars, fractions, dates and music tracks.

D.1.2 Distinguish between an object (definition, template or class) and instantiation.

  • Students must understand the difference in terms of code definitions, memory use and the potential creation of multiple instantiated objects.

D.1.3 Construct unified modelling language (UML) diagrams to represent object designs.

  • LINK Connecting computational thinking and program design.

D.1.4 Interpret UML diagrams.

  • LINK Connecting computational thinking and program design.

D.1.5 Describe the process of decomposition into several related objects.

  • A simple example with 3–5 objects is suggested. Examples related to D.1.1 could be employers, traffic simulation models, calculators, calendars, media collections.
  • LINK Thinking abstractly.
  • AIM 4 Applying thinking skills critically to decompose scenarios.

D.1.6 Describe the relationships between objects for a given problem.

  • The relationships that should be known are dependency (“uses”), aggregation (“has a”) and inheritance (“is a”).
  • LINK Thinking abstractly.
  • AIM 4 Applying thinking skills critically to decompose scenarios.

D.1.7 Outline the need to reduce dependencies between objects in a given problem.

  • Students should understand that dependencies increase maintenance overheads.

D.1.8 Construct related objects for a given problem.

  • In examinations problems will require the students to construct definitions for no more than three objects and to explain their relationships to each other and to any additional classes defined by the examiners.
  • LINK Connecting computational thinking and program design.
  • AIM 4 Applying thinking and algorithmic skills to resolve problems.

D.1.9 Explain the need for different data types to represent data items.

  • The data types will be restricted to integer, real, string and Boolean.

D.1.10 Describe how data items can be passed to and from actions as parameters.

  • Parameters will be restricted to pass-by-value of one of the four types in D.1.6. Actions may return at most one data item.

Unit D2: OOP features

D.2.1 Define the term encapsulation.

  • Data and actions are limited to the object in which they are defined.

D.2.2 Define the term inheritance.

  • A parent object holds common data and actions for a group of related child objects. Multiple inheritance is not required.

D.2.3 Define the term polymorphism.

  • Actions have the same name but different parameter lists and processes.

D.2.4 Explain the advantages of encapsulation.

  • For example, the scope of data should be confined to the object in which it is defined as far as possible in order to limit side effects and dependencies.

D.2.5 Explain the advantages of inheritance.

  • For example, a parent object holds common data and actions, which enhances reuse and reduces maintenance overheads.

D.2.6 Explain the advantages of polymorphism.

  • For example, an action in a child object may choose to override actions of a parent object. This allows an external program to use the same action on a family of objects without knowing the implementation detail.

D.2.7 Describe the advantages of libraries of objects.

  • For example, sorts and other complex algorithms and processes do not have to be “re-invented”.

D.2.8 Describe the disadvantages of OOP.

  • For example, increased complexity for small problems; unsuited to particular classes of problem.
  • AIM 9 Develop an appreciation of the limitations of OOP.

D.2.9 Discuss the use of programming teams.

  • As compared to individuals working alone. Examples include speed to completion, information hiding to reduce module dependencies, expertise in narrow fields (eg testing, documentation), etc.
  • INT, AIM 5 The need to develop a common “language” to enable collaboration across international frontiers when resolving problems.

D.2.10 Explain the advantages of modularity in program development.

  • Advantages include easier debugging and testing, speedier completion, etc.

Unit D3: OOP programming

D.3.1 Define the terms: class, identifier, primitive, instance variable, parameter variable, local variable.

  • These are generally related to the object’s data. See JETS.

D.3.2 Define the terms: method, accessor, mutator, constructor, signature, return value.

  • These are generally related to the object’s actions. See JETS.

D.3.3 Define the terms: private, protected, public, extends, static.

  • These are generally related to the OOP features described in D.2. See JETS.

D.3.4 Describe the uses of the primitive data types and the reference class string.

  • In examination questions the primitive types will be limited to int, long, double, char and Boolean.
  • MYP Mathematics: forms of numbers.

D.3.5 Construct code to implement assessment statements D.3.1–D.3.4.

  • Students may be asked to trace, explain or construct algorithms using the concepts associated with the terms.

D.3.6 Construct code examples related to selection statements.

  • Students may be asked to trace, explain or construct algorithms using simple and compound if … else constructs.

D.3.7 Construct code examples related to repetition statements.

  • Students may be asked to trace, explain or construct algorithms using for, while or do … while loops.

D.3.8 Construct code examples related to static arrays.

  • Students may be asked to trace, explain or construct algorithms using static arrays.

D.3.9 Discuss the features of modern programming languages that enable internationalization.

  • For example, use of UNICODE character sets.
  • INT When organizations interact, particularly on an international basis, there may be issues of language differences.

D.3.10 Discuss the ethical and moral obligations of programmers.

  • For example, adequate testing of products to prevent the possibilities of commercial or other damage. Acknowledging the work of other programmers. The main aims of the Open Source movement should be known.
  • S/E, AIM 8 An awareness of the ethical considerations when developing new code.

Unit D4: OOP programming advanced (HL)

D.4.1 Define the term recursion.

D.4.2 Describe the application of recursive algorithms.

  • Students should understand that recursion can be applied to a small subset of programming problems to produce elegant solutions. Students should also understand that recursive algorithms are rarely used in practice.
  • LINK Thinking abstractly, thinking recursively.

D.4.3 Construct algorithms that use recursion.

  • This is limited to a method that returns no more than one result and contains either one or two recursive calls.
  • LINK Connecting computational thinking and program design.

D.4.4 Trace recursive algorithms.

  • All steps and calls must be shown clearly.
  • LINK Connecting computational thinking and program design.

D.4.5 Define the term object reference.

  • As typified by simple classes that are self-referential.

D.4.6 Construct algorithms that use reference mechanisms.

D.4.7 Identify the features of the abstract data type (ADT) list.

  • Students should understand the nature of an ADT—where no implementation details are known but the actions/methods are standard.

D.4.8 Describe applications of lists.

  • Students should understand that lists can be used to represent stacks and queues.

D.4.9 Construct algorithms using a static implementation of a list.

  • Lists will be restricted to singly linked types. Methods that should be known are add (head and tail), insert (in order), delete, list, isEmpty, isFull.

D.4.10 Construct list algorithms using object references.

  • Lists will be restricted to singly linked types. Methods that should be known are add (head and tail), insert (in order), delete, list, isEmpty, isFull.

D.4.11 Construct algorithms using the standard library collections included in JETS.

  • The classes are ArrayList and LinkedList. Students should have a broad understanding of the operation of these lists and their interface (methods) but not of the internal structure.

D.4.12 Trace algorithms using the implementations described in assessment statements D.4.9–D.4.11.

  • In examination questions, definitions of ArrayList and LinkedList methods will be given where necessary.

D.4.13 Explain the advantages of using library collections.

  • Students should understand that libraries provide convenient and reliable implementations of common programming tasks.

D.4.14 Outline the features of ADT’s stack, queue and binary tree.

  • Students should be able to provide diagrams, applications and descriptions of these ADTs. For example, they should know that a binary tree can be used to efficiently store and retrieve unique keys.

D.4.15 Explain the importance of style and naming conventions in code.

  • Students should understand that meaningful identifiers, proper indentation and adequate comments all improve the readability of code for humans and thus save money, time and effort in programming teams.
  • INT, AIM 5 The need to develop a common “language” to enable collaboration across international frontiers when resolving problems.