Mark Brown Private Tuition

network ├── area │ ├── local-area-network │ ├── metropolitan-area-network │ ├── personal-area-network │ └── wide-area-network ├── authentication │ ├── biometric │ ├── captcha │ ├── certificate │ ├── keypass │ ├── passwords │ ├── signature │ └── two-factor-authentication ├── client-server │ ├── client-side │ └── server-side ├── data-transmission │ ├── asynchronous │ ├── bandwidth │ ├── baud-rate │ ├── bit-rate │ ├── error-check │ │ ├── automatic-repeat-request │ │ ├── checksum │ │ ├── double-entry-check │ │ ├── echo-check │ │ ├── format-check │ │ ├── length-check │ │ ├── parity-check │ │ └── presence-check │ ├── full-duplex │ ├── half-duplex │ ├── latency │ ├── multiplexing │ ├── parallel │ ├── serial │ ├── simplex │ ├── streaming │ │ ├── on-demand-streaming │ │ └── real-time-streaming │ └── synchronous ├── internet │ ├── isp │ └── web │ ├── browser │ ├── cascading-style-sheets │ ├── cloud-storage │ ├── crud │ │ ├── create │ │ ├── create-read-update-delete │ │ ├── delete │ │ ├── read │ │ └── update │ ├── dns │ ├── email │ ├── hypertext-markup-language │ ├── javascript │ ├── json │ ├── search-engine │ ├── url │ ├── website │ └── xml ├── network-calculation ├── network-hardware │ ├── bridge │ ├── firewall │ ├── gateway │ ├── hub │ ├── network-interface-card │ ├── network-wireless │ ├── router │ ├── switch │ └── wired-wireless ├── network-model │ ├── client-server │ │ ├── client-side │ │ └── server-side │ ├── lan-wan │ └── peer-to-peer ├── protocols │ ├── dhcp │ ├── email-protocols │ │ ├── imap │ │ ├── pop3 │ │ └── smtp │ ├── ftp │ ├── http │ │ ├── create │ │ ├── delete │ │ ├── get │ │ ├── https │ │ ├── hypertext-transport-protocol │ │ ├── post │ │ ├── put │ │ ├── rest │ │ └── update │ ├── ssl │ └── udp ├── security │ ├── acceptable-use-policy │ ├── audit-trail │ ├── authentication │ │ ├── biometric │ │ ├── captcha │ │ ├── certificate │ │ ├── keypass │ │ ├── passwords │ │ ├── signature │ │ └── two-factor-authentication │ ├── encryption │ │ ├── asymmetric-encryption │ │ ├── encryption-caesar │ │ ├── encryption-cipher │ │ ├── encryption-xor │ │ ├── public-key-encryption │ │ ├── quantum-encryption │ │ ├── symmetric-encryption │ │ ├── vernam-cipher │ │ └── xor-encryption │ ├── mac-address-filtering │ ├── os-security │ ├── penetration-testing │ ├── physical │ ├── security-antivirus │ └── threats │ ├── blagging │ ├── data-interception │ ├── malware │ ├── phishing │ ├── shouldering │ ├── social-engineering │ ├── spyware │ ├── trojan │ ├── virus │ └── worm ├── server ├── switching │ ├── circuit-switching │ └── packet-switching ├── tcp-ip │ ├── application-layer │ │ └── port │ ├── internet-layer │ │ ├── dynamic │ │ ├── ipv4 │ │ ├── ipv6 │ │ ├── network-address-translation │ │ ├── private-ip │ │ ├── public-ip │ │ ├── static │ │ └── subnet-mask │ ├── link-layer │ │ ├── mac-address │ │ └── network-hardware │ │ ├── bridge │ │ ├── firewall │ │ ├── gateway │ │ ├── hub │ │ ├── network-interface-card │ │ ├── network-wireless │ │ ├── router │ │ ├── switch │ │ └── wired-wireless │ └── transport-layer │ ├── packet │ ├── packet-switching │ └── packets ├── threats │ ├── blagging │ ├── data-interception │ ├── malware │ ├── phishing │ ├── shouldering │ ├── social-engineering │ ├── spyware │ ├── trojan │ ├── virus │ └── worm ├── topology │ ├── bus-topology │ │ ├── csma-cd │ │ └── data-collision │ ├── hybrid-topology │ ├── mesh-topology │ ├── ring-topology │ └── star-topology └── transport-layer ├── packet ├── packet-switching └── packets

programming ├── iteration │ ├── for-loop │ └── while-loop ├── programming-fundamentals │ ├── assembly │ │ └── little-man-computer │ ├── bytecode │ ├── concurrent │ ├── function │ │ ├── coroutine │ │ ├── function-procedure │ │ ├── generator │ │ ├── procedure │ │ ├── recursion │ │ ├── sub-procedure │ │ └── sub-program │ ├── input-process-output │ ├── iteration │ │ ├── for-loop │ │ └── while-loop │ ├── programming-io │ ├── recursion │ ├── selection │ │ ├── boolean-tests │ │ ├── conditional │ │ ├── elif │ │ ├── else │ │ ├── goto │ │ └── if │ ├── sequence │ └── variable │ ├── addressing-mode │ │ ├── direct-mode │ │ ├── immediate-mode │ │ ├── indexed-mode │ │ └── indirect-mode │ ├── complex-data-type │ │ ├── composite │ │ ├── date │ │ └── string │ ├── data-type │ │ ├── abstract-data-type │ │ ├── bool │ │ ├── char │ │ ├── float │ │ ├── int │ │ └── non-composite │ ├── global-local │ ├── pointer │ ├── programming-constant │ ├── reference-value │ └── type-cast ├── programming-library │ ├── non-standard-library │ └── standard-library ├── programming-paradigm │ ├── assembly │ │ └── little-man-computer │ ├── batch-processing │ ├── declarative-programming │ │ └── sql │ ├── functional-programming │ ├── imperative-programming │ ├── logical-programming │ ├── markup │ ├── object-oriented-programming │ │ ├── class │ │ ├── constructor │ │ ├── inheritance │ │ ├── method │ │ ├── overriding │ │ ├── polymorphism │ │ ├── private │ │ ├── protected │ │ └── public │ ├── parallel-processing │ ├── procedural-programming │ └── programming-async ├── reusable-component ├── selection │ ├── boolean-tests │ ├── conditional │ ├── elif │ ├── else │ ├── goto │ └── if ├── structure └── variable ├── addressing-mode │ ├── direct-mode │ ├── immediate-mode │ ├── indexed-mode │ └── indirect-mode ├── complex-data-type │ ├── composite │ ├── date │ └── string ├── data-type │ ├── abstract-data-type │ ├── bool │ ├── char │ ├── float │ ├── int │ └── non-composite ├── global-local ├── pointer ├── programming-constant ├── reference-value └── type-cast

hardware ├── bios ├── control-system │ ├── automation │ └── safety-critical ├── cpu │ ├── arithmetic-logic-unit │ │ ├── full-adder │ │ └── half-adder │ ├── cpu-architecture │ │ ├── harvard │ │ └── von-neumann │ ├── cpu-bus │ │ ├── address-bus │ │ ├── control-bus │ │ └── data-bus │ ├── cpu-component │ │ ├── arithmetic-logic-unit │ │ │ ├── full-adder │ │ │ └── half-adder │ │ ├── cache │ │ ├── clock │ │ ├── control-unit │ │ └── register │ │ ├── general-purpose-register │ │ └── special-purpose-register │ ├── cpu-interrupt │ ├── cpu-performance │ │ ├── cache │ │ ├── clock-speed │ │ ├── multicore-cpu │ │ └── pipelining │ ├── dedicated-register │ │ ├── accumulator │ │ ├── current-instruction-register │ │ ├── memory-address-register │ │ ├── memory-buffer-register │ │ ├── memory-data-register │ │ ├── program-counter │ │ └── status-register │ ├── fetch-decode-execute-cycle │ │ ├── decode │ │ ├── execute │ │ └── fetch │ ├── instruction-set │ │ ├── cisc │ │ ├── cisc-risc │ │ └── risc │ ├── microprocessor │ ├── realtime-cpu │ └── register │ ├── general-purpose-register │ └── special-purpose-register ├── input-output │ ├── input │ │ ├── analogue-to-digital │ │ ├── camera │ │ │ └── ccd │ │ ├── fingerprint-reader │ │ ├── keyboard │ │ ├── mouse │ │ ├── natural-language-interface │ │ ├── sensor │ │ └── touch-screen │ └── output │ ├── actuator │ ├── gpu │ ├── printer │ ├── screen │ └── speaker ├── mainframe ├── memory │ ├── buffer │ │ ├── double-buffer │ │ └── single-buffer │ ├── cloud-storage │ ├── dtype-flip-flop │ ├── memory-ff │ ├── memory-ram │ ├── non-volatile │ ├── paging │ ├── primary-storage │ ├── random-access-memory │ ├── read-only-memory │ ├── reading-memory │ │ ├── random-access │ │ └── sequential-access │ ├── secondary-storage │ ├── segmentation │ ├── virtual-memory │ └── volatile ├── motherboard ├── storage │ ├── cloud-storage │ ├── hard-disk-drive │ ├── hdd-vs-sdd │ ├── hdd-vs-ssd │ ├── optical-media │ ├── storage-backup │ ├── storage-dvd │ ├── storage-external │ └── storage-ssd ├── super-computer └── thin-thick

software-engineering ├── accessibility ├── application-software │ └── bespoke ├── artificial-intelligence │ ├── deep-learning │ ├── expert-system │ └── machine-learning ├── big-data ├── computational-method │ ├── backtracking │ ├── data-mining │ ├── pipelining │ └── visualisation │ ├── abstract-data-type │ ├── entity-relationship-diagram │ └── flowchart ├── debugging │ ├── error │ │ ├── linking-error │ │ ├── logic-error │ │ ├── rounding-error │ │ ├── runtime-error │ │ ├── syntax-error │ │ └── truncation-error │ ├── flowchart │ ├── trace │ ├── trace-table │ └── validation ├── dev-model │ ├── rapid-application-development │ ├── waterfall │ └── xp-model ├── documentation ├── integrated-development-environment ├── operating-system │ ├── device-driver │ ├── distributed-os │ ├── embedded-os │ ├── file-system │ │ └── hierarchical │ ├── memory-management │ │ └── segmentation │ ├── os-multitasking │ ├── os-security │ ├── os-user │ ├── os-virtual │ ├── paging │ ├── real-time-os │ ├── scheduler │ │ └── first-come-first-served │ └── utility-software │ ├── backup │ ├── copying │ └── defragmentator ├── project │ ├── analysis │ ├── design │ │ ├── changeover │ │ ├── feasibility-study │ │ └── software-design │ ├── development │ ├── evaluation │ │ ├── performance │ │ ├── scalability │ │ └── usability │ └── implementation ├── pseudocode ├── simulation ├── software │ └── integrated-development-environment ├── testing │ ├── mock-data │ └── stub-testing ├── user-interface │ ├── graphical-user-interface │ ├── menu-user-interface │ ├── text-user-interface │ └── voice-input ├── version-control ├── virtual-machine └── virtualisation

mathematics ├── algebra ├── boolean-algebra │ ├── de-morgans-law │ ├── karnaugh-map │ ├── logic-gate │ │ ├── and │ │ ├── nand │ │ ├── nor │ │ ├── not │ │ ├── or │ │ ├── relay │ │ └── xor │ └── truth-table ├── combinatorics │ ├── combinations │ └── permutations ├── geometry ├── number │ └── number-representation │ ├── binary │ │ ├── binary-operations │ │ │ ├── binary-addition │ │ │ ├── binary-shift │ │ │ │ ├── arithmetic-shift │ │ │ │ └── logical-shift │ │ │ ├── binary-subtraction │ │ │ ├── bitwise-mask │ │ │ └── signed-int-addition │ │ ├── fixed-point │ │ ├── floating-point │ │ │ ├── absolute-error │ │ │ ├── relative-error │ │ │ ├── rounding │ │ │ └── truncation │ │ └── signed-integer │ ├── binary-shift │ │ ├── arithmetic-shift │ │ └── logical-shift │ ├── overflow │ └── underflow ├── number-operation │ ├── binary-addition │ ├── infix-notation │ ├── postfix-notation │ └── prefix-notation ├── number-operations │ ├── divmod │ ├── modulus │ └── number-calculation ├── radix-positional │ ├── base │ ├── binary │ │ ├── binary-operations │ │ │ ├── binary-addition │ │ │ ├── binary-shift │ │ │ │ ├── arithmetic-shift │ │ │ │ └── logical-shift │ │ │ ├── binary-subtraction │ │ │ ├── bitwise-mask │ │ │ └── signed-int-addition │ │ ├── fixed-point │ │ ├── floating-point │ │ │ ├── absolute-error │ │ │ ├── relative-error │ │ │ ├── rounding │ │ │ └── truncation │ │ └── signed-integer │ ├── denary │ ├── hexadecimal │ └── octal └── vector

data-structure ├── array │ ├── array-2d │ └── array-3d ├── binary-tree │ ├── balancing-tree │ ├── binary-tree-representation │ ├── binary-tree-traversal │ │ ├── in-order-traversal │ │ ├── post-order-traversal │ │ └── pre-order-traversal │ ├── in-order-traversal │ ├── post-order-traversal │ └── pre-order-traversal ├── database │ ├── data-dictionary │ ├── database-acid │ ├── distributed-database │ ├── flat-file-database │ ├── indexing │ │ └── multi-level-index │ ├── logical-schema │ ├── normalisation │ ├── referential-integrity │ └── relational │ ├── entity-relational-diagram │ ├── entity-relationship-diagram │ ├── field │ ├── foreign-key │ ├── many-to-many │ ├── many-to-one │ ├── one-to-many │ ├── one-to-one │ ├── primary-key │ ├── record │ ├── secondary-key │ ├── sql │ └── table ├── dataframe ├── graph ├── hash-table ├── linked-list ├── queue │ ├── circular-queue │ ├── linear-queue │ └── priority-queue ├── record ├── set │ └── cardinality ├── stack ├── string └── tree

data-representation ├── bit-depth ├── data-size │ ├── bit │ ├── byte │ ├── gibi │ ├── giga │ ├── kebi │ ├── kibi │ ├── kilo │ ├── mebi │ ├── mega │ ├── nibble │ ├── tebi │ ├── tera │ └── word ├── image-representation │ ├── bitmap │ ├── colour-depth │ └── vector ├── number-representation │ ├── binary │ │ ├── binary-operations │ │ │ ├── binary-addition │ │ │ ├── binary-shift │ │ │ │ ├── arithmetic-shift │ │ │ │ └── logical-shift │ │ │ ├── binary-subtraction │ │ │ ├── bitwise-mask │ │ │ └── signed-int-addition │ │ ├── fixed-point │ │ ├── floating-point │ │ │ ├── absolute-error │ │ │ ├── relative-error │ │ │ ├── rounding │ │ │ └── truncation │ │ └── signed-integer │ ├── binary-shift │ │ ├── arithmetic-shift │ │ └── logical-shift │ ├── overflow │ └── underflow ├── sound-representation │ ├── frequency │ ├── midi │ ├── nyquist │ ├── sample-resolution │ └── sampling-rate ├── text-representation │ ├── ascii │ └── unicode └── video-representation

language ├── halting-problem ├── high-low-language ├── interrupt │ ├── cpu-interrupt │ └── programming-interrupt ├── intractable-problem ├── named-languages │ ├── cascading-style-sheets │ ├── hypertext-markup-language │ ├── java │ ├── javascript │ ├── little-man-computer │ ├── lua │ ├── markup │ ├── python │ ├── sql │ └── turtle ├── program-translator │ ├── assembler │ ├── compilation │ ├── compiler │ ├── compiler-interpreter │ ├── interpreter │ ├── lexical-analysis │ ├── linker │ ├── machine-code │ └── optimisation └── regular-language ├── backus-naur-form ├── ebnf ├── finite-state-machine ├── regular-expression └── turing-machine

algorithm ├── complexity ├── compression │ ├── huffman-compression │ ├── lossless-compression │ ├── lossy-compression │ └── run-length-encoding ├── hash ├── min-max ├── scheduler │ └── first-come-first-served ├── sort │ ├── bubble-sort │ ├── insertion-sort │ ├── iteration-sort │ ├── merge-sort │ └── quick-sort └── traversal ├── a* ├── binary-tree-traversal │ ├── in-order-traversal │ ├── post-order-traversal │ └── pre-order-traversal ├── graph-traversal │ ├── dijiskra │ └── travelling-salesman └── search ├── binary-search ├── breadth-first-search ├── depth-first-search └── linear-search

philosophy ├── cultural ├── environmental ├── ethical │ ├── accessibility │ ├── ai │ ├── code-of-conduct │ ├── piracy │ ├── threats │ │ ├── blagging │ │ ├── data-interception │ │ ├── malware │ │ ├── phishing │ │ ├── shouldering │ │ ├── social-engineering │ │ ├── spyware │ │ ├── trojan │ │ ├── virus │ │ └── worm │ └── vulnerabilities │ ├── ethical-hacking │ ├── footprinting │ ├── penetration-testing │ └── physical-access ├── legal │ └── licence │ ├── open-closed │ └── open-source └── societal └── digital-currency

meta ├── calculation ├── coding-exercise ├── errata │ ├── code-of-conduct │ ├── nonsense │ │ └── cake │ └── professional-integrity ├── essay ├── fill-in-the-blanks ├── heuristic ├── logic-puzzle ├── multiple-choice ├── problem-solving │ ├── abstraction │ ├── backtracking │ ├── decomposition │ ├── encapsulation │ └── recognition ├── pseudocode ├── section-b └── trace-table

(orphaned) ├── language-fundamentals ├── network-topology └── network-transport