Java programming and OOP

Either to revise or as additional sources, the followins resources may help you with Java programming and OOP.

• This YouTube video playlist teaches Java programming with OOP as its main focus ("Early Objects" we could say).
• https://chortle.ccsu.edu/java5/Notes/chap92/ch92_2.html lexicographical order/Java compareTo method
• https://www.youtube.com/playlist?list=PLZPZq0r_RZOMhCAyywfnYLlrjiVOkdAI1 (up to 47 for the whole course; up to 25 for grade 11) ; https://www.youtube.com/watch?v=xk4_1vDrzzo
• https://www.youtube.com/watch?v=eIrMbAQSU34 great for our level and grade 11 IB CS
• https://www.youtube.com/watch?v=j9VNCI9Xo80 another great resource for our level and grade 11 IB CS; up to 02:17:14 - Exercise
• https://www.udemy.com/course/java-tutorial/
• https://www.sololearn.com/learn/courses/java-introduction
• https://www.freecodecamp.org/news/the-java-handbook/ (up to and excluding array lists for grade 11, all but excluding hash maps for grade 12)
• https://www.coursera.org/learn/object-oriented-java
• https://www.youtube.com/codingwithjohn
  

 Hope they will be useful to you!

ROM and RAMs

I found this great article on the differences between BIOS (basic input/output system) and EFI/UEFI (Unified Extended Firmware Interface), which are the contents of the ROM, which is actually flash memory, non-volatile and writable.

Something to note is that in this context of flash ROM, we could say that ROM means read-only, or not writeable, but from a user perspective rather than a hardware limitation. Updating the (ROM) BIOS/UEFI is a process handled by special applications (BIOS updaters or flashers) that check and update it, or may even be an advanced option offered by the UEFI/BIOS itself.

Althogh the concept of RAM (Random Access Memory), the primary storage keeping instructions and data to be used by the processor, is not tough to grasp, the difference between static and dynamic RAM is a bit tougher. Watch this great video explaining below. Credits go to H3Vtux.

You may also want to watch TechQuickie's "Different Kinds of Memory as Fast As Possible":

And finally, this nice quizlet cards may help you revise the topic of Computer Organisation.

Lexicographical Order

This refers to the way strings and characters are alphabetised and compared.

In Java, you need to understand lexicographical order to properly implement (and debug) sorting algorithms.

The page below has the best, most concise and practical explanation I have found so far:

• Lexicographical Order @ https://chortle.ccsu.edu/java5/Notes/chap92/ch92_2.html

Towers of Hanoi Problem

The link below probably has the best explanation to understand and solve the Towers of Hanoi problem.

https://www.freecodecamp.org/news/analyzing-the-algorithm-to-solve-the-tower-of-hanoi-problem-686685f032e3/

IB Final Papers Revision

Just a last reminder to help you prepare for your IB final papers.

• https://youtu.be/hP5TNI_2VRs how to keep focused (general advice)
• This former IB DP CS student summarises the general recommendations we have shared in class: https://youtu.be/RtWxiryDrek
• http://www.teachcomputing.net/ib/computer-science.html
• http://ibcomp.fis.edu
• I've updated my blog with links to topics you requested in class: http://technomess.blogspot.com/search/label/ib

Best luck in your revision and finals!

Computer Networks

Best of YouTube videos on Computer Networks

Some of these links, rather than pointing to individual videos, will take you to YouTube channels containing many videos on the topic. Note that some videos or parts of a video may not be relevant to your specific syllabus or needs.

• https://www.youtube.com/playlist?list=PL7zRJGi6nMRzHkyXpGZJg3KfRSCrF15Jg This playlist also contains videos about CPU cache, BIOS/CMOS/UEFI, printers, and RAM.
• https://www.youtube.com/playlist?list=PLDQaRcbiSnqF5U8ffMgZzS7fq1rHUI3Q8 another thorough playlist about networking.
• https://youtu.be/svkGASq8mNM Computer Networking Tutorial for Beginners (detailed!)
• https://www.youtube.com/@PowerCertAnimatedVideos PowerCertAnimatedVideos channel @ YouTube

Big O notation

Best of YouTube videos and links on Big O notation

Hope these videos help. Remember to check your textbooks as well! You may also want to read chapter 14 of Big Java Late Objects (Horstmann) and chapter 15 of Java Illuminated (Anderson and Franceschi).

• https://youtu.be/__vX2sjlpXU 5 minutes introduction
• https://youtu.be/aj59L-_7V70 another introduction, part 1/3; with C++ examples (cout << is similar to print)
• https://youtu.be/5kBP1Kmye10 another introduction, part 2/3
• https://youtu.be/5AxcXHPB3GE part 3/3 of another introduction, relevant mostly to Higher Level students as it involves recursion
• https://youtu.be/6TsmsGn-N0E you may ignore references to omega and theta, which are outside the scope of our IB DP Computer Science course.
• https://youtu.be/V6mKVRU1evU with examples in Java
• https://www.bigocheatsheet.com/
• https://bigocheatsheet.io/
• https://www.geeksforgeeks.org/analysis-algorithms-big-o-analysis/
  
• https://www.freecodecamp.org/news/big-o-notation-why-it-matters-and-why-it-doesnt

Warm up to Computer Science

These resources will help you practice and strengthen your Computer Science and practical programming skills. Multiple links are provided to cover a wider range of backgrounds, experience and needs.

Python is a great first programming language to learn for beginners, and Java is second to none to learn OOP and intermediate to advanced programming concepts. Java is a must for computer science students, and is also the prescribed programming language for the IB Diploma Programme Computer Science course with the Object Oriented Programming (OOP) option.

Good luck!

Theory/General Knowledge:

• Computer Science foundation course @ BBC Bytesize GCSE Computer Science (click here to see all available examination board options for Computer Science)
• A general IT course @ BBC Bytesize GCSE ICT, if you are new to IT/computer subjects
• Crash course: Computer Science series of videos by PBS (great!)
• Map of Computer Science video shows all the fields of study under Computer Science
  

Practical aspect: Programming

• Programming Tips for Beginners
• Free Python Interactive Tutorial @ Sololearn (only on the first 30 modules are essential and recommended for an introduction to programming with Python)
• Free Java Interactive Tutorial @ Sololearn
• Learn Java online in Chinese or English @ learnjavaonline.org
• Java Tutorial for Complete Beginners @ Udemy
  

Free eBooks recommended:

• http://greenteapress.com/wp/think-python-2e/
• http://greenteapress.com/wp/think-java/
• http://greenteapress.com/wp/think-data-structures/
  

A few of the best reference sites about Java programming are

• http://www.tutorialspoint.com/java/
• http://beginnersbook.com/java-tutorial-for-beginners-with-examples/
• https://www.codementor.io/collections/learn-java-online-bwbbwjibt

Memory and Storage Devices

Videos related to the Computer Architecture topic (memory and storage devices)

• https://www.youtube.com/watch?v=NtPc0jI21i0 How a Hard Disk Drive Works
• https://www.youtube.com/watch?v=wteUW2sL7bc how do HDDs work
• https://www.youtube.com/watch?v=FS3jmgIzwO4 open HDD working
• https://www.lifewire.com/what-is-fragmentation-defragmentation-2625884
• https://en.wikipedia.org/wiki/Defragmentation nice animation to demonstrate concepts
• https://computer.howstuffworks.com/solid-state-drive.htm

• https://www.youtube.com/watch?v=dZcszUj5szA memory types
• https://www.youtube.com/watch?v=g1N3l1l43kE Main Memory (RAM, ROM and Cache)
• https://www.youtube.com/watch?v=ELl3abwYQ90 flash memory
• https://blogs.systweak.com/2017/04/how-to-increase-virtual-memory-in-windows-7/
• http://www.techiesweb.com/a-small-overview-of-system-virtual-memory-and-windows-paging-concepts/

Adders

A webpage with a nice and detailed explanation of half and full adders:

https://www.elprocus.com/half-adder-and-full-adder/

Testing

A couple of good resources on testing, including alpha, beta, white and black box testing:

• http://toolsqa.com/software-testing/difference-between-alpha-testing-and-beta-testing/
• http://www.softwaretestingclass.com/what-is-alpha-and-beta-testing/

2's Complement

Notes on two's complement can be found here. To supplement our textbook, our lectures and exercises.

Source: https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html

UML Class Diagrams in a Nutshell

...A really small nutshell.

This webpage contains a nice, short and sweet explanation and side-be-side comparison between a class diagram and its corresponding Java code. Priceless.

Source: http://pages.cs.wisc.edu/~hasti/cs302/examples/UMLdiagram.html

Analogue vs Digital

These couple of resources may help you understand the difference between analogue and digital data:

• http://www.dummies.com/programming/electronics/the-difference-between-analog-and-digital-electronics/
• http://www.explainthatstuff.com/analog-and-digital.html
• https://www.youtube.com/watch?v=RQc_frX50BA

Class Relationships

Please read these two resources to have a better understanding of class relationships

• http://creately.com/blog/diagrams/class-diagram-relationships/ focus on association, composition/aggregation (depends on your IA), multiplicity and inheritance. http://www.infoworld.com/article/3029325/application-development/exploring-association-aggregation-and-composition-in-oop.html (link title explains itself)

For more resources on the principles of OOP and UML diagrams, click here.

OOP Principles and UML

These are my favourite explanations (so far) regarding the principles of OOP: Abstraction, Encapsulation, Inheritance and Polymorphism. They are most important to understand and remember, so study and practice them well. The links have page names (at the end of the link) that are self-explanatory.

• http://codebetter.com/raymondlewallen/2005/07/19/4-major-principles-of-object-oriented-programming
• http://beginnersbook.com/2013/03/oops-in-java-encapsulation-inheritance-polymorphism-abstraction/
• http://www.javaworld.com/article/2076204/core-java/understanding-constructors.html

UML provides so many tools, that it can be overwhelming. So it is always useful to narrow it down and focus on what is useful for a specific task. The following resources are on UML class diagrams. You are also recommended to look into use-case diagrams, which are great for conceptual designs.

• http://pages.cs.wisc.edu/~hasti/cs302/examples/UMLdiagram.html
• http://etutorials.org/Programming/UML/Chapter+4.+Class+Diagrams+The+Essentials/
• http://etutorials.org/Programming/UML/Chapter+6.+Class+Diagrams+Advanced+Concepts/Aggregation+and+Composition/
• http://www.uml-diagrams.org/class-diagrams-overview.html
• http://creately.com/blog/diagrams/class-diagram-relationships/
• http://www.infoworld.com/article/3029325/application-development/exploring-association-aggregation-and-composition-in-oop.html
• http://pages.cs.wisc.edu/~hasti/cs302/examples/UMLdiagram.html
• http://www.tutorialspoint.com/uml/uml_class_diagram.htm
• http://www.ibm.com/developerworks/rational/library/content/RationalEdge/sep04/bell/

In terms of class relationships, you should know (according to the IBO syllabus content)

• dependency (“uses”)
• aggregation (“has a”) and
• inheritance (“is a”).

You may find the following links useful to revise these concepts. Just focus on what IBO requires among all the detailed information provided.

• http://www.conceptdraw.com/How-To-Guide/uml-class-diagram-notation
• https://en.wikipedia.org/wiki/Class_diagram

FDE Cycle

Fetch-Decode-Execute Cycle

Links with information about the FDE cycle, from simple & concise to deeper and more detailed:

• GCSE Bytesize (Instructions)
• The Fetch–Execute cycle and the role of registers within it (A level Computing WikiBook)
• Also known as the Instruction cycle (Wikipedia article)

An excellent flow chart depicting the FDE cycle (original source https://en.wikipedia.org/wiki/Instruction_cycle):

Plus a nice animation demonstrating how the fetch-decode-execute cycle works, made using Scratch:

• https://scratch.mit.edu/projects/2145440/

I have also made my own, simplified version for study and revision purposes:

Sorting and Searching Algorithms

Resources, animations and videos of sorting and searching algorithms:

The following links point to videos and video channels showing animations of different sorting algorithms. More than one video is provided so that you may pick the one you understand best. You could also build your understanding from a few sources as well.

• https://visualgo.net/ - excellent interactive animated sorting algorithms out there
• http://www.sorting-algorithms.com - sorting algorithm animations, discussed
• https://www.geeksforgeeks.org/fundamentals-of-algorithms/ self-explanatory
  
• http://xoax.net/comp_sci/crs/algorithms/ - concise and well illustrated videos about different algorithms.
• http://www.cs.armstrong.edu/liang/animation/ - animations on algorithms, plus data structures and other topics.
• https://www.youtube.com/user/AlgoRythmics/videos - algorithms illustrated with European traditional folk dances

Sequential (Linear) and Binary searches:

• https://www.geeksforgeeks.org/linear-search/
• https://www.geeksforgeeks.org/binary-search/
  
• https://youtu.be/wNVCJj642n4 (Both)
• https://youtu.be/vZWfKBdSgXI (Linear search only)
• https://youtu.be/CX2CYIJLwfg (Linear search only)
• https://youtu.be/5xlIPT1FRcA (Binary search only)
• https://youtu.be/D5SrAga1pno (Binary search only)

Bubble sort:

• https://www.geeksforgeeks.org/bubble-sort
• https://www.programiz.com/dsa/bubble-sort
  
• https://youtu.be/yIQuKSwPlro
• https://youtu.be/UnK5ueUgc88
• https://youtu.be/y_Nuui4Qf-k
• https://youtu.be/P00xJgWzz2c

Selection sort:

• https://www.geeksforgeeks.org/selection-sort
• https://www.programiz.com/dsa/selection-sort
• https://youtu.be/f8hXR_Hvybo
• https://youtu.be/79AB11J5BqU
• https://youtu.be/TW3_7cD9L1A
• https://youtu.be/Aq2E47uU2ao
• https://youtu.be/6nDMgr0-Yyo

Insertion sort:

• https://www.geeksforgeeks.org/insertion-sort
• https://www.programiz.com/dsa/insertion-sort
  
• https://youtu.be/c4BRHC7kTaQ
• https://youtu.be/JU767SDMDvA
• https://youtu.be/OGzPmgsI-pQ
• https://youtu.be/OxN2Jqb8S9s
• https://youtu.be/Fr0SmtN0IJM

https://www.geeksforgeeks.org/comparison-among-bubble-sort-selection-sort-and-insertion-sort/

Algorithms and Abstract Data Types HL

Resources about various algorithms - Higher Level:

1. http://www.algolist.net/Algorithms/ - various algorithms (sort, binary search) and programming concepts (recursion) explained
2. From this link, be sure to revise the sequential and binary searches, plus the chapters on sorting algorithms and recursion (code examples are on Python, which means it's close to pseudocode, but you can run it if you have the Python 3 interpreter)
3. http://introcs.cs.princeton.edu/java/40algorithms/ - an excellent chapter on Algorithms and Data Structures; there was a performance question in a recent past paper, so it may be a good idea to read 4.1 (performance) as well. Don't obsess over Tilde notation and skip memory usage as well. Our focus is to be aware of how some algorithms are more efficient than others (as you can see by their classification into their order of growth: constant, logarithmic, linear, quadratic, cubic, exponential, etc.)
Stacks and Queues
Binary Search Trees

Resources about Abstract Data Types:

• http://www.webopedia.com/TERM/A/abstract-data-type.html
• http://www.csanimated.com/animation.php?t=Abstract_data_type
• http://www.csanimated.com/animation.php?t=Stack
• http://www.csanimated.com/animation.php?t=Queue
• http://www.csanimated.com/animation.php?t=Linked_list
• http://visualgo.net/en/list.html - animated ADTs (linked list implementations)
• Chapter on Linked Lists, from the same site as #2 in the previous list of links ;-)
• http://www.algolist.net/Data_structures/ - well explained and clear diagrams
• HackerRank's algorithms YoutTube playlist
• HackerRank's data structures YoutTube playlist
• mycodeschool's YouTube playlist on data structures. Examples are in C/C++, but their explanations and diagrams are great!
  

2D Arrays and IB Pseudocode

This brief post shows how to create a bi-dimentional array and describe it using IB pseudocode. It isn't stated in the IB Pseudocode in Examinations or Approved notation for developing pseudocode documents, so it's my answer to it, not an official one. Don't sue me if your examiner disagrees with me! O_o

declare A as integer array of size [ROWS][COLUMNS] or
declare A as integer array of size (ROWS, COLUMNS)
declare A as integer array of size [5][6]
declare A as integer array of size (5, 6)

Obviously, integer should be replaced by the appropriate data type.
IB papers may have defined it for you, or they may not ask you at all to define the size. You could define it (unknown size) as

declare A as integer array of size [ ][ ]

...then you'd use it like

loop ROW from 0 to 5
    loop COL from 0 to 6
        output A[ROW][COL]     or    output A(ROW, COL) 
    end loop
end loop

I'd recommend going for the [ ][ ] style as it'd be more consistent with the single dimensional arrays described in the IB pseudocode documents mentioned above.