Table of contents
  1. Mock test
  2. In-class test 1 details
  3. In-class test 1 examinability
  4. In-class test 2 details
  5. In-class test 2 examinability

Your grade for the unit will come from two in-class tests, which are exams in all but name. The first will be worth 40%, and will cover Kira’s part of the unit; the second will be worth 60%, and will cover John’s part of the unit. In each test, half the marks will be from a practical component (where you’ll be doing the same sort of thing as in your weekly assignments) and the other half will be from an online theory component on Blackboard (where you’ll be doing the same sort of thing as in your weekly workshops).

The first class test worth 40% of the unit will be held in week 6 on Wednesday October 23rd at 10am. For most students, this will be in MVB 2.11 (the same room as your weekly labs). Students with Alternative Exam Arrangements (AEAs) such as extra time will take the test in a different venue, usually MVB 1.15, but will be emailed seperately by the school office to confirm this.

The second class test worth 60% of the unit will be held in week 13 on Thursday December 12th at 1pm. Again, for most students this will be in MVB 2.11 (the same room as your weekly labs). Students with Alternative Exam Arrangements (AEAs) such as extra time will take the test in a different venue, usually MVB 1.15, but will be emailed seperately by the school office to confirm this.

The following rules will apply for assessments taking place as an in class test. They have been designed in line with the University’s exam regulations and to ensure standardisation across units.

  • In class tests are in person and cannot be sat remotely. Submitting anything from outside the test room will be considered academic malpractice.
  • Once in the test room you are required to be silent.
  • No additional time will be allowed for students arriving late.
  • No one is allowed to leave in the first 30 minutes or final 15 minutes of the test. Everyone is to remain in the room.
  • If you arrive more than 30 minutes after the start of the test, you will not be allowed into the test and will be directed to your school Office 2.19 Merchant Venturers Building.
  • You need to have your UCard with you to be shown on arrival so that your attendance can be recorded, it should also be visible on your desk at all times during the in class test.
  • You will be required to leave all bags and coats at the back of the room so please leave valuables at home wherever possible and also ensure that you are appropriately dressed for the venue and weather.
  • Drinks bottles are allowed provided they contain water only and have no labels or writing on them. Food is not allowed unless you have a medical need, in which case you should make an invigilator aware.
  • Mobile phones, smart watches or other electronic devices are not allowed at your desk.
  • You will have use of a computer.
  • All tests should be submitted in English.
  • Unless explicitly specified otherwise, no translation software, Internet access or other software is allowed other than Blackboard access to the in-class test. In particular, you are not allowed access to any other part of the unit page or unit materials on Blackboard. In this test, you are also allowed access to the exam version of Logisim and the Calculator app (in Standard and Scientific modes ONLY).
  • Unless explicitly specified, no outside materials (e.g. printed or handwritten notes or digital files) are allowed.
  • We will carry out random spot checks on people’s computers to ensure they are not using any forbidden software or materials.

Mock test

In week 5 we will run a mock test - more details will be available closer to the time. This will be almost exactly like the real test in terms of procedures, but it doesn’t have any marks associated with it and will only last for a few minutes. The point is just to make sure that everyone knows exactly what the real test will involve, what’s allowed and what isn’t. Attendance is optional but encouraged.

In-class test 1 details

In-class test 1 will consist of two parts. The first part, the theory part, will be an auto-marked Blackboard test in exactly the same format as the Blackboard quizzes from live sessions. It will contain roughly 11 questions and will be marked out of 50. Partial credit will be available for multi-part questions. The second part, the practical part, will ask you to modify and submit a skeleton Logisim file with one subcircuit for each question. It will contain 4 questions and will also be marked out of 50. You will get full marks for any circuit which behaves as specified in the question, with partial marks available for circuits with minor bugs - in particular, you will not be marked based on neatness, choice of components, or your approach to the problem unless this is specifically noted in the question. Each question will have a list of which components you are allowed to use - in addition to this, you may create your own subcircuits or use anything in the “wiring” sub-menu. Your final mark for test 1 will be the sum of your marks for the theory and practical part.

You will be allowed use of the exam version of Logisim only, available here. The only difference between this and the normal version of Logisim is that it removes the Project -> Analyse Circuit menu option, which gives various options like automatically building a circuit from a truth table that would be too powerful in an exam setting. Use of the non-exam version of Logisim will be considered academic malpractice (i.e. cheating).

You will be allowed use of the pre-installed calculator apps (Calculator or KCalc) only, in their standard or scientific modes only. (In Calculator, these are called “basic” and “advanced”; in KCalc, they are called “simple” and “science”.) In particular, you must not use any mode of any calculator app with native support for binary, octal, or hexadecimal numbers; typically this mode is called a “programming” mode or similar. You may not bring a physical calculator into the test, as most physical calculators have the ability to convert automatically between decimal and binary. Use of any calculator or calculator mode with native support for binary, octal, or hexadecimal numbers will be considered academic malpractice.

You will be given rough paper and a physical copy of this reference sheet and the test paper (both the practical part and the theory part). Do not bring your own rough paper or reference sheet into the test room. The reference sheet contains:

  • A table of SI units.
  • A reference for behaviour of the Hack ALU.
  • The formula introduced in lectures for calculating base-2 logarithms from base-10 or base-e logarithms.

During the test, an invigilator may briefly interrupt you and ask to see all the applications you have open. This is typically nothing to worry about - we will be carrying out these checks randomly throughout the test to prevent cheating, and they only take a few seconds.

Results and feedback will be made available no later than 2-3 weeks after the test, accompanied by a Blackboard announcement.

Two practice papers are available below; the actual test will be similar in form and content. Note that these papers don’t have any questions on transistors, but transistors are examinable.

In-class test 1 examinability

By default, all material covered in lecture slides and in assignments is examinable, and all material covered only in live sessions or in recommended reading is non-examinable. (Material covered in e.g. both the lecture slides and live sessions is of course examinable.)

Over the course of the weekly assignments, you’re expected to have become familiar with Logisim components for circuits we’ve covered explicitly (e.g. counters, registers, flip-flops etc.) in the lecture slides. You’re not expected to have become familiar with Logisim components for circuits we haven’t covered (e.g. shift registers, comparators etc.) It’s also worth remembering that in the exam, you can always hover over a pin of a Logisim component to get a quick reminder of what it does, so you don’t have to memorise anything.

The following material is non-examinable, despite appearing in lecture slides or assignments:

Week 1:

  • Venn diagrams from week 1 video 1 (“Boolean algebra”) are non-examinable.
  • The detailed circuit diagrams of NAND boards from week 1 video 4 (“NAND”) are non-examinable. In particular, you are not expected to know anything about resistors.
  • You will not be asked to do anything with NAND boards physically (e.g. building circuits). You may still be asked questions about NAND boards in the theory component, e.g. being given a picture of a NAND board and being asked to match pins to functions.
  • The method from the week 1 assignment of implementing an XOR gate with four NAND gates is non-examinable.

Week 2:

  • In week 2 video 1 (“Representing numbers”), on slide 8, the formula for the value of a base-B number is given in sigma-notation. This notation is non-examinable. The formula itself (that a D-digit base-B number with digits xD-1, xD-2, …, x1, x0 from left to right has value xD-1*BD-1 + xD-2*BD-2 + … + x1*B + x0*1) is still examinable.
  • The IEEE-754 standard alluded to in week 2 video 3 (“Binary subtraction”) is non-examinable. Expressing a binary number in exponent-mantissa form in general (e.g. expressing 2.75 as a mantissa of 0b1011 and an 8-bit exponent of -2 = 0b11111110) is still examinable, as is the general concept of IEEE-754 (e.g. you should understand that it defined how values like NaN and infinity should be stored).
  • Your specific implementation of the Hack ALU from the week 2 assignment is non-examinable. (Behaviour of the Hack ALU is examinable, though.)

Week 3:

  • The failed register design from week 3 video 3 (“From flip-flops to registers”) is non-examinable, although you should understand why it fails and be able to identify similar issues in other circuits.
  • You are expected to be able to calculate logarithms with access to a calculator using the formula from week 3 video 3 (“From registers to RAM”), and to be able to apply their definition to solve problems in circuit design (e.g. “if RAM consists of 32KB of memory divided into 16-bit words, how many bits are needed to store an address?”). Every other aspect of logarithms is non-examinable and you are not expected to have seen them before starting the degree. In particular, you do not need to know how to prove the formula log2(x) = logb(x) / logb(2) given in lectures, or how to calculate logarithms without a calculator supporting log or ln, or the definition of e, or properties like log(xy) = log(x) + log(y).
  • Ring oscillators (the set of 5 NOT gates) from the week 3 assignment are non-examinable.
  • T flip-flops and JK flip-flops from the week 3 assignment are non-examinable, although you may use them as components in Logisim if you wish to do so (and the question does not restrict which components you use).

Week 4:

  • BJT transistors from week 4 video 2 (“Transistors”) are non-examinable.
  • The finite state machine used by Celeste linked in week 4 video 1 (“Building with flip-flops and registers”) is non-examinable, and you are not expected to have looked at it.
  • The rise/fall detector and traffic lights from the week 4 assignment are non-examinable, although the general skill of designing complex circuits is examinable.

In-class test 2 details

In-class test 2 will consist of two parts. The first part, the theory part, will be an auto-marked Blackboard test in exactly the same format as the Blackboard quizzes from live sessions and the theory part of test 1. It will contain roughly 11 questions and will be marked out of 50. Partial credit will be available for multi-part questions. The second part, the practical part, will ask you to submit a .zip file with one .asm file for each question. It will contain 4 questions and will also be marked out of 50. You will get full marks for any assembly program which behaves as specified in the question, with partial marks available for programs with minor bugs - in particular, if your program works then you will not be marked down based on neatness, code hygiene, efficiency, or your approach to the problem unless this is specifically noted in the question. However, if your code doesn’t work, you may get partial credit based on your thought process. For this reason, we recommend writing comments as you go. Your final mark for test 2 will be the sum of your marks for the theory and practical part.

You will be allowed use of the following software only:

  • Our fork of the Hack CPU emulator.
  • A web browser (which may only be used to fill out the theory part of the test and submit the practical part of the test).
  • The pre-installed text editor “Text editor” to write your assembly code. (You are not allowed to use VS Code, as there are Hack plugins available for it.)
  • The pre-installed calculator apps (Calculator and KCalc) in any mode.
  • A terminal only to start the CPU emulator and assembler (since they run as shell scripts).

You may not bring a physical calculator into the test, as in the absence of an approved model whitelist it’s hard to tell from a distance which calculators are programmable and which aren’t. You will be given rough paper and a physical copy of this reference sheet and the test paper (both the practical part and the theory part). Do not bring your own rough paper or reference sheet into the exam room. Use of outside materials will be considered academic malpractice and dealt with harshly. The reference sheet contains:

  • A table of Hack characters and their integer values.
  • A reference for the format of A-instructions, C-instructions, and most of Hack assembly.
  • A reference for the arithmetic and logical operations supported by Hack VM.
  • A reference for the standard memory map from Hack VM to Hack assembly.

Results and feedback will be made available in January by email at the same time as your results from Programming in C and Overview of Software Tools. Two practice papers will be made available here closer to the time.

Two practice papers are available below; the actual test will be similar in form and content.

In-class test 2 examinability

By default, all material covered in lecture slides and in assignments is examinable, and all material covered only in live sessions or in recommended reading is non-examinable. (Material covered in e.g. both the lecture slides and live sessions is of course examinable.)

Some material is non-examinable despite appearing in lecture slides or assignments - this is usually flagged at the time. Here is a full list of what is not examinable:

General:

  • You will not be examined on your ability to program in C or your knowledge of C syntax. However, you are expected to understand the basic concepts of programming taught in that unit (e.g. loops, functions, pointers etc.) insofar as this unit relies on it, and questions may use examples from C for illustrative purposes. For example, a question might refer to “an abstract data type (such as a struct in C or a class in Jack)”.
  • Specific details of C’s behaviour not covered in Programming in C (like the difference between char *myArray = “Hello, world!”; and char myArray[] = “Hello, world!”; covered in week 11 video 3) are also non-examinable and are provided purely for illustrative purposes.
  • You will only be examined on weeks 1-4 insofar as weeks 5 and 7-11 rely on this content. For example, you will not be asked to convert a hexadecimal number into decimal as a question in its own right, but you may well be given a memory address in hexadecimal format and need to convert that address into decimal format as part of answering a larger question in the practical part of the exam.
  • You will not be asked to design any circuits or to use Logisim in the practical part of the exam.
  • The specific solutions for weekly assignments from weeks 5, 7, 8 and 11 are non-examinable except insofar as they overlap with lectures. For example, you will be expected to know how to write a program like checkerfill.asm from the week 5 assignment, but you will not be expected to have memorised checkerfill.asm and you won’t be asked to reproduce it.
  • The C code for weekly assignments from weeks 9 and 10 is non-examinable, but you will be expected to know how to translate Hack VM code into Hack assembly code and may be asked to do so (as in the practice papers).
  • Any specific details of non-Hack assembly languages are non-examinable. For example, you will be expected to understand the difference between direct and indirect addressing from week 7 video 3, but you will not be expected to remember the ARM syntax for either. General properties of non-Hack assembly languages (such as that ARM is used in most modern mobile devices) remain examinable.

Week 5:

  • The definition of a Turing machine in video 3 is non-examinable. The other contents of the slide (the Church-Turing thesis, Turing-completeness, and the Halting Problem) are examinable, though only at the level covered by the slide.

Week 7:

  • Exact details of specific CPUs mentioned in videos 3-4, such as the number of cycles required per instruction or the time in nanoseconds to retrieve data from memory. (However, you are expected to remember the key qualitative details that are common across all CPUs, such as L3 cache access being slower than L1 cache access.)

Week 8:

  • The Hack assembly grammar is examinable, but you don’t need to memorise the definition – if questions are asked about it, you will be given the relevant excerpts of the EBNF. The same is true for the grammars covered in video 3.
  • The last slide of video 2 (on using multiple symbol tables to handle scopes in a high-level language) is only examinable insofar as it overlaps with the week 11 material.

Week 9:

  • The Hack VM grammar is examinable, but you don’t need to memorise the definition – if questions are asked about it, you will be given the relevant excerpts of the EBNF.

Week 11:

  • You are not expected to know how to program in Jack. You will not be asked about the details of Jack as a language, and you will not be asked to read, write, or debug Jack code. However, you are expected to understand both the general principles of how to compile a high-level language into Hack VM to the full extent that this is explored in Jack. For example, you are expected to know what a method is, and you might be asked about the process of compiling a method to Hack VM, but you will not be asked to read, write, or debug a method declaration in Jack.
  • Likewise, the Jack grammar is examinable, but you don’t need to memorise the definition – if questions are asked about it, you will be given the relevant excerpts of the EBNF.
  • Likewise, with the exceptions of Memory.alloc, Memory.deAlloc, and Sys.init (all of which you are expected to know), any details you need of the Hack “operating system” as covered in Nisan and Schocken Appendix 6 will be provided to you.