<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Home on Mohsin Kaleem</title><link>https://mohkale.gitlab.io/</link><description>Recent content in Home on Mohsin Kaleem</description><generator>Hugo -- gohugo.io</generator><language>en-us</language><lastBuildDate>Thu, 23 Sep 2021 00:00:00 +0000</lastBuildDate><atom:link href="https://mohkale.gitlab.io/index.xml" rel="self" type="application/rss+xml"/><item><title>Introducing My Brain Dump</title><link>https://mohkale.gitlab.io/posts/2021/09/23/introducing-my-brain-dump/</link><pubDate>Thu, 23 Sep 2021 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2021/09/23/introducing-my-brain-dump/</guid><description>Well, it's been quite a while since my last post. Almost 7 months by my count ｜−・;）. I'll try to explain this absence in an upcoming post looking back on my time at university however I think it's about time to update the little robots who scrape this blog with what I've been up to: My Personal Brain Dump.
The Motivation Near the start of my last year at university I increasingly started to realise the impracticality of how I took and reviewed notes.</description></item><item><title>GNU parallel is xargs on Steroids</title><link>https://mohkale.gitlab.io/posts/2021/02/22/gnu-parallel-is-xargs-on-steroids/</link><pubDate>Mon, 22 Feb 2021 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2021/02/22/gnu-parallel-is-xargs-on-steroids/</guid><description>Lets talk about xargs. It's useful, reliable and far too inflexible.
What is xargs? For those that're unfamiliar, xargs is a POSIX program that's used to build command lines. You produce some output (or supply a text file) and each line of that output is substituted into a command line and then evaluated. For example, if I have a list of urls in a file foo.txt:
https://foo.com/bar https://foo.com/baz https://foo.com/bag and I'd like to download all of them with curl, I can run:</description></item><item><title>Soak up Pipelines with sponge</title><link>https://mohkale.gitlab.io/posts/2021/01/04/soak-up-pipelines-with-sponge/</link><pubDate>Mon, 04 Jan 2021 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2021/01/04/soak-up-pipelines-with-sponge/</guid><description>While migrating my vipe script from perl to python, I had the chance to look into more of the programs in the moreutils project. While there were a few that seemed really useful, sponge is far and away the most practical utility I've seen. In this post lets explore the issues and applications of the sponge utility.
Accidentally Truncating Files sponge addresses a common use case when working with a shell pipeline: modifying files in place.</description></item><item><title>Year in Review 2020</title><link>https://mohkale.gitlab.io/posts/2020/12/31/year-in-review-2020/</link><pubDate>Thu, 31 Dec 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/12/31/year-in-review-2020/</guid><description>Well, the end has come. 2020 has been a chaotic, hectic, messy year. The dominating topic of discussion for this year was, and will continue to be, the novel Corona-Virus. With over 83 million worldwide recorded cases and almost 2 million deaths, this pandemic will regrettably be remembered as the defining marker to the entrance of the 2020s.
This year has tested all of our collective patience. With lock-downs lasting the majority of it and an entire political divide forming between those who want a prompt return to normalcy and those advocating caution and patience to avoid exacerbating the ongoing pandemic.</description></item><item><title>Hamefura S01</title><link>https://mohkale.gitlab.io/posts/2020/12/08/hamefura-s01/</link><pubDate>Tue, 08 Dec 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/12/08/hamefura-s01/</guid><description>Introduction Hamefura is a generic wholesome harem anime with isekai and romcom tropes. We're introduced to the protagonist, Katerina Claes as young girl entering her first year at a magical school, before a flashback immediately takes us back to her as young child.
Boisterous and spoiled, she's introduced as the only daughter of an affluent family who wants for nothing. One day while on a walk with a prince she trips and has an awakening.</description></item><item><title>Programmer Strings</title><link>https://mohkale.gitlab.io/exercises/programmer-strings/</link><pubDate>Tue, 24 Nov 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/programmer-strings/</guid><description>Test Cases programmer_strings(&amp;#39;progxrammerrxproxgrammer&amp;#39;) # 2 programmer_strings(&amp;#39;programmerprogrammer&amp;#39;) # 0 programmer_strings(&amp;#39;xprogxrmaxemrppprmmograeiruu&amp;#39;) # 2</description></item><item><title>Max Positive Slice Sum</title><link>https://mohkale.gitlab.io/exercises/max-positive-slice-sum/</link><pubDate>Tue, 20 Oct 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/max-positive-slice-sum/</guid><description/></item><item><title>BST In-Order Successor</title><link>https://mohkale.gitlab.io/exercises/bst-in-order-successor/</link><pubDate>Mon, 19 Oct 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/bst-in-order-successor/</guid><description>Tree Implementation We'll store the tree structure as a simple class, with an additional method to assign the parent fields so we don't have to create the parents and then assign the children separately.
import dataclasses @dataclasses.dataclass class Node: value: int left: Optional[&amp;#39;Node&amp;#39;] = None right: Optional[&amp;#39;Node&amp;#39;] = None parent: Optional[&amp;#39;Node&amp;#39;] = None @staticmethod def assign_parents(tree): def recursive_do(parent, node): if node is not None: node.parent = parent recursive_do(node, node.left) recursive_do(node, node.</description></item><item><title>Numbers Disappeared in an Array</title><link>https://mohkale.gitlab.io/exercises/disappeared-from-array/</link><pubDate>Wed, 14 Oct 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/disappeared-from-array/</guid><description/></item><item><title>Equal Split (2 Array)</title><link>https://mohkale.gitlab.io/exercises/equal-split-2-array/</link><pubDate>Mon, 12 Oct 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/equal-split-2-array/</guid><description>Utils Used to accumulate the sum from the start of the array to index i for each index i in the array arr.
def prefix_sum(arr): if len(arr) == 0: return [] mem = [0] * len(arr) mem[0] = arr[0] for i in range(1, len(arr)): mem[i] = mem[i-1] + arr[i] return mem</description></item><item><title>Stone Wall</title><link>https://mohkale.gitlab.io/exercises/stone-wall/</link><pubDate>Thu, 08 Oct 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/stone-wall/</guid><description/></item><item><title>Avoid Code Smells With Lazy Iterables</title><link>https://mohkale.gitlab.io/posts/2020/10/02/avoid-code-smells-with-lazy-iterables/</link><pubDate>Fri, 02 Oct 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/10/02/avoid-code-smells-with-lazy-iterables/</guid><description>The other day, I finally got tired of xdg-open not working properly with KDE5 and decided to fork and build my own open script from pyxdg-open. Now I quite liked using a python based file opener but while inspecting the source code I saw a frequent use of a design pattern which I can only classify as code-smell. In this post let's break down what I mean by code smell and ways to avoid it with lazy iterables.</description></item><item><title>Fish</title><link>https://mohkale.gitlab.io/exercises/fish/</link><pubDate>Wed, 30 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/fish/</guid><description/></item><item><title>Passing Cars</title><link>https://mohkale.gitlab.io/exercises/passing-cars/</link><pubDate>Tue, 29 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/passing-cars/</guid><description/></item><item><title>Tape Equilibrium</title><link>https://mohkale.gitlab.io/exercises/tape-equilibrium/</link><pubDate>Sat, 26 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/tape-equilibrium/</guid><description/></item><item><title>Binary Gap</title><link>https://mohkale.gitlab.io/exercises/binary-gap/</link><pubDate>Wed, 23 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/binary-gap/</guid><description/></item><item><title>Frog Jump</title><link>https://mohkale.gitlab.io/exercises/frog-jump/</link><pubDate>Tue, 22 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/frog-jump/</guid><description>Analysis The part of this solution that has the most apparent performance benefit is how we determine the terminating condition. A simple zero check is all we need to know whether all the leaves we need have dropped or not. That's the benefit of storing problem states in individual bits. It may seem difficult to know when a compact representation like binary makes sense, but the runtime gains are immense. See unique-number.</description></item><item><title>Django</title><link>https://mohkale.gitlab.io/notes/django/</link><pubDate>Thu, 17 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/notes/django/</guid><description>Django is a web framework for quickly creating scalable fault torrent web applications using python.
Getting Started You're gonna need to have python 3 installed. I also recommend a package manager such as poetry to maintain project dependencies. After you've got both those you can bootstrap a new project named foo in the cwd.
poetry init poetry add django poetry run django-admin startproject foo . This should've generated a directory structure like:</description></item><item><title>Galton Board</title><link>https://mohkale.gitlab.io/exercises/galton-board/</link><pubDate>Thu, 10 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/galton-board/</guid><description>Potential Optimizations My solution above has an large runtime cost because its recalculating paths as it recurses. Take for example the following scenario.
+-----------+ | S |-- | | | | | | | | | |-|-&amp;gt; | | | | | G | +-----------+ In this case we're viewing two different recursive invocations. The first decided to go to the right at the start and then down twice. The second decided to go down twice and then to the right.</description></item><item><title>EDN is the JSON of My Dreams</title><link>https://mohkale.gitlab.io/posts/2020/09/03/edn-is-the-json-of-my-dreams/</link><pubDate>Thu, 03 Sep 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/09/03/edn-is-the-json-of-my-dreams/</guid><description>EDN (aka the Extensible Data Notation) is a lisp like data serialisation format. Think JSON, but written in LISP. I just spent the better part of an hour migrating a python project I had that used JSON as a config format to EDN... and I'm probably never going to use JSON when EDN is an option again.
How it looks EDN is a subset of clojure, meaning in general, it looks just like lisp.</description></item><item><title>The Case for Terminal File Managers</title><link>https://mohkale.gitlab.io/posts/2020/08/29/the-case-for-terminal-file-managers/</link><pubDate>Sat, 29 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/08/29/the-case-for-terminal-file-managers/</guid><description>A file manager is a program that lets you interact with a file-system. A filesystem is the abstraction used by your OS to expose the data stored on your computer (in a hard drive, a virtual partition etc.) or any external devices (such as a memory stick). Most users will really only be familliar with large, graphical file managers such as windows file explorer or on linux, GNOME Files or Konqueror (more recently KDE dolphin).</description></item><item><title>Combination Sum</title><link>https://mohkale.gitlab.io/exercises/combination-sum/</link><pubDate>Thu, 27 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/combination-sum/</guid><description>Utils fun &amp;lt;T&amp;gt; cloneListAdd(lst: List&amp;lt;T&amp;gt;, value: T): List&amp;lt;T&amp;gt; { val newList = lst.toMutableList() newList.add(value) return newList.toList() } Tests combinationSum(listOf(2,4,6,3), 6) // [[2, 2, 2], [2, 4], [6], [3, 3]] Potential Optimizations Avoiding Unecessary Stack Allocations My implementation above has a strange quirk. In recursiveDo we're checking if sum + num &amp;lt;= target but in the next allocation we're checking if sum == target. Meaning we've checked sum == target twice. It's a minor performance penalty but irksome all the same.</description></item><item><title>Array Product Excluding Self</title><link>https://mohkale.gitlab.io/exercises/array-product-excluding-self/</link><pubDate>Wed, 26 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/array-product-excluding-self/</guid><description/></item><item><title>Gold Rush</title><link>https://mohkale.gitlab.io/exercises/gold-rush/</link><pubDate>Tue, 25 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/gold-rush/</guid><description>Utils type Map = [][]int func variadicMax(nums ...int) int { if len(nums) == 0 { panic(&amp;#34;must provide at least one num&amp;#34;) } val := 0 for _, num := range nums { if num &amp;gt; val { val = num } } return val }</description></item><item><title>Word Search</title><link>https://mohkale.gitlab.io/exercises/word-search/</link><pubDate>Mon, 24 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/word-search/</guid><description>Test Cases sm = SearchMap.new([ [&amp;#39;C&amp;#39;,&amp;#39;A&amp;#39;,&amp;#39;T&amp;#39;,&amp;#39;F&amp;#39;], [&amp;#39;B&amp;#39;,&amp;#39;G&amp;#39;,&amp;#39;E&amp;#39;,&amp;#39;S&amp;#39;], [&amp;#39;I&amp;#39;,&amp;#39;T&amp;#39;,&amp;#39;A&amp;#39;,&amp;#39;E&amp;#39;] ])sm.search(&amp;#34;CAT&amp;#34;) # true sm.search(&amp;#34;TEA&amp;#34;) # true sm.search(&amp;#34;SEAT&amp;#34;) # true sm.search(&amp;#34;BAT&amp;#34;) # false sm.search(&amp;#34;TIBI&amp;#34;) # false # snake pattern going across rows sm.search(&amp;#34;CBITGATEAESF&amp;#34;) # true # snake pattern going across columns sm.search(&amp;#34;CATFSEATIBGE&amp;#34;) # true</description></item><item><title>Generate Text Messages</title><link>https://mohkale.gitlab.io/exercises/generate-text-messages/</link><pubDate>Sun, 23 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/generate-text-messages/</guid><description>Utils val digitMap = mapOf( &amp;#39;0&amp;#39; to &amp;#34;&amp;#34;, &amp;#39;1&amp;#39; to &amp;#34;&amp;#34;, &amp;#39;2&amp;#39; to &amp;#34;abc&amp;#34;, &amp;#39;3&amp;#39; to &amp;#34;def&amp;#34;, &amp;#39;4&amp;#39; to &amp;#34;ghi&amp;#34;, &amp;#39;5&amp;#39; to &amp;#34;jkl&amp;#34;, &amp;#39;6&amp;#39; to &amp;#34;mno&amp;#34;, &amp;#39;7&amp;#39; to &amp;#34;pqrs&amp;#34;, &amp;#39;8&amp;#39; to &amp;#34;tuv&amp;#34;, &amp;#39;9&amp;#39; to &amp;#34;wxyz&amp;#34;, ) Test Cases genMessages(&amp;#34;23&amp;#34;).toList() // [ad, ae, af, bd, be, bf, cd, ce, cf] genMessages(&amp;#34;203&amp;#34;).toList() // [ad, ae, af, bd, be, bf, cd, ce, cf] genMessages(&amp;#34;123&amp;#34;).toList() // [aad, aae, aaf, abd, abe, abf, acd, ace, acf, bad, bae, baf, bbd, bbe, bbf, bcd, bce, bcf, cad, cae, caf, cbd, cbe, cbf, ccd, cce, ccf] Potential Optimisations There's quite a bit of repeated work involved in this solution.</description></item><item><title>String Case Permutations</title><link>https://mohkale.gitlab.io/exercises/string-case-permutations/</link><pubDate>Sat, 22 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/string-case-permutations/</guid><description>Utils These are the definitions of the functions that I've used in the solution and while testing.
/** * Append a value to a slice immutably. Returns a new slice, while leaving * the original slice in place. */ func immutableAppend(slice []rune, ch rune) []rune { clone := make([]rune, len(slice)+1) copy(clone, slice) clone[len(slice)] = ch return clone } /** * Run case permutations and then print the output as a slice.</description></item><item><title>Same Leaves</title><link>https://mohkale.gitlab.io/exercises/same-leaves/</link><pubDate>Fri, 21 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/same-leaves/</guid><description>Tree Implementation interface Tree { value: number left?: Tree right?: Tree } function isLeaf(t: Tree) { return t.left === undefined &amp;amp;&amp;amp; t.right === undefined; } Test Cases Setup We'll be testing using the following trees:
1 tree_a: / \ 1 3 7 tree_b: / \ 1 2 8 / \ tree_c: 2 29 / \ 3 9 8 / \ tree_d: 2 29 / / \ 2 3 9 \ 3 Which in our implementation looks like:</description></item><item><title>Symmetric Binary Tree Predicate</title><link>https://mohkale.gitlab.io/exercises/symmetrical-bst/</link><pubDate>Thu, 20 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/symmetrical-bst/</guid><description>Test Cases Setup We'll be implementing our trees using this class:
data class Tree(val value: Int, val left: Tree?=null, val right: Tree?=null) And while not explicitly mentioned, the questions seems to be looking for a function taking a single tree argument (instead of both left and right subtrees) so let's create an auxiliary function to dispatch to our solution:
fun isSymmetricRoot(t: Tree): Boolean { // the current root node doesn&amp;#39;t matter, so discard it.</description></item><item><title>Using fzf as a dmenu Replacement</title><link>https://mohkale.gitlab.io/posts/2020/08/20/using-fzf-as-a-dmenu-replacement/</link><pubDate>Thu, 20 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/08/20/using-fzf-as-a-dmenu-replacement/</guid><description>A while back I read a post by Ömür Özkir about using fzf as a replacement for dmenu. For those that're unfamiliar.
dmenu is an application dispatcher. It pops up with a bunch of options for you to choose and then does something with them. It's commonly configured to pop up with a list of the programs installed on your system and then starts the program you select. Luke Smith made an excellent video about dmenu, I highly recommend checking it out.</description></item><item><title>Validate Binary Search Tree</title><link>https://mohkale.gitlab.io/exercises/validate-bst/</link><pubDate>Wed, 19 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/validate-bst/</guid><description>Tree Implementation type Tree struct { value int left, right *Tree } Test Cases Setup We'll be testing using the following tree structures:
2 Tree a: / \ 1 3 1 Tree b: / \ 2 3tree_a := Tree{2, &amp;amp;Tree{1, nil, nil}, &amp;amp;Tree{3, nil, nil}, } tree_b := Tree{1, &amp;amp;Tree{2, nil, nil}, &amp;amp;Tree{3, nil, nil}, } Tests validBst(&amp;amp;tree_a) // true validBst(&amp;amp;tree_b) // false</description></item><item><title>Level Based Tree Traversal</title><link>https://mohkale.gitlab.io/exercises/n-ary-tree-traversal/</link><pubDate>Tue, 18 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/n-ary-tree-traversal/</guid><description>Tree Implementation Tree = Struct.new(&amp;#34;Tree&amp;#34;, :value, :children) do def initialize(value, children=[]) super end end Test Cases Setup We'll be testing using the following trees:
8 Tree A: / | \ 2 3 29 2 / | \ 1 6 9 Tree B: / | \ 8 2 2 / | \ 19 12 90tree_a = Tree.new( 8, [ Tree.new(2), Tree.new(3), Tree.new(29), ] ) tree_b = Tree.new( 2, [ Tree.new(1, [ Tree.</description></item><item><title>Root to Leaf Path Sum</title><link>https://mohkale.gitlab.io/exercises/root-to-leaf-sum/</link><pubDate>Mon, 17 Aug 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/root-to-leaf-sum/</guid><description>Tree Implementation type TreeNode = { value: number, left?: TreeNode, right?: TreeNode } function isLeaf(node: TreeNode) { return node.left === undefined &amp;amp;&amp;amp; node.right === undefined } Test Cases Setup We'll be testing using the following trees.
1 / \ Tree A: 5 2 / / \ 1 12 29 104 / \ Tree B: 39 31 / \ / \ 32 1 9 10 Which in our implementation looks like:</description></item><item><title>Middle of a Linked List</title><link>https://mohkale.gitlab.io/exercises/linked-list-middle/</link><pubDate>Tue, 21 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/linked-list-middle/</guid><description>Linked List Implementation class Node: def __init__(self, value, next=None): self.value = value self.next = next @classmethod def from_list(cls, lst): parent = None for elem in reversed(lst): parent = cls(elem, next=parent) return parent</description></item><item><title>Group Anagrams</title><link>https://mohkale.gitlab.io/exercises/group-anagrams/</link><pubDate>Mon, 20 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/group-anagrams/</guid><description>Test Cases groupAnagrams([&amp;#34;eat&amp;#34;, &amp;#34;tea&amp;#34;, &amp;#34;tan&amp;#34;, &amp;#34;ate&amp;#34;, &amp;#34;nat&amp;#34;, &amp;#34;bat&amp;#34;]) /* [ [&amp;#34;ate&amp;#34;,&amp;#34;eat&amp;#34;,&amp;#34;tea&amp;#34;], [&amp;#34;nat&amp;#34;,&amp;#34;tan&amp;#34;], [&amp;#34;bat&amp;#34;] ] */ Alternative Implementation Another way to approach this problem is by constructing a hashing function that hashes anagrams to themselves, but different strings to a unique hash. I.E. a string based, order insensitive, hashing function.
function isPrime(i) { for (let j=2; j &amp;lt;= i / 2; j++) { if (i % j === 0) { return false } } return true } /* first prime number greater than {@code n}.</description></item><item><title>Move Zeroes</title><link>https://mohkale.gitlab.io/exercises/move-zeroes/</link><pubDate>Sun, 19 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/move-zeroes/</guid><description>Test Cases move_zeroes([0,1,0,3,12]) # [1,3,12,0,0] move_zeroes([1]) # [1]</description></item><item><title>Happy Number</title><link>https://mohkale.gitlab.io/exercises/happy-number/</link><pubDate>Sat, 18 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/happy-number/</guid><description>Test Cases using all happy numbers under 100.
happies = [1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49, 68, 70, 79, 82, 86, 91, 94, 97, 100] (2..100).each do |num| is_happy = happy_num?(num) if is_happy != happies.include?(num) if is_happy puts &amp;#34;FAILED: #{num}is happy when it shouldn&amp;#39;t be&amp;#34; else puts &amp;#34;FAILED: #{num}is not happy when it should be&amp;#34; end end end # As with unix, silence is good 😄.</description></item><item><title>Unique Number</title><link>https://mohkale.gitlab.io/exercises/unique-number/</link><pubDate>Fri, 17 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/unique-number/</guid><description>Test Cases uniqueNum(listOf(1,2,3,2,1)) // 3 uniqueNum(listOf(1)) // 1 uniqueNum(listOf(2,2,1)) // 1 uniqueNum(listOf(4,1,2,1,2)) // 4</description></item><item><title>Number Intersection</title><link>https://mohkale.gitlab.io/exercises/number-intersection/</link><pubDate>Thu, 16 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/number-intersection/</guid><description>Analysis we build a hashmap storing the characters that occur in a in \(\mathcal{O}(a)\) time and then simply return the characters in b that match a. This has space complexity and time complexity \(\mathcal{O}(n)\) where n is the length of the intersection of a and b.
Note we've used mem.delete because otherwise if a character in a occurs more than once in b, then we'll end up including it in the return value more than once as well.</description></item><item><title>kotlin</title><link>https://mohkale.gitlab.io/notes/kotlin/</link><pubDate>Wed, 15 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/notes/kotlin/</guid><description>TODO reified types /* * The top of the file should start with the current package namespace. */ package moe.kisara.learn // then any desired imports, by default kotlin auto imports these. import kotlin.* import kotlin.annotations.* import kotlin.collections.* import kotlin.comparisons.* import kotlin.io.* import kotlin.ranges.* import kotlin.sequences.* import kotlin.text.* // when targeting the java platform these are also imported import java.lang.* import kotlin.jvm.* // you can alias an import to some other identifier import moe.</description></item><item><title>Spot the Difference</title><link>https://mohkale.gitlab.io/exercises/shuffled-clone-difference/</link><pubDate>Wed, 15 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/shuffled-clone-difference/</guid><description>Test Cases string_diff(&amp;#39;foobar&amp;#39;, &amp;#39;barfoot&amp;#39;) // &amp;#39;t&amp;#39; string_diff(&amp;#39;ide&amp;#39;, &amp;#39;idea&amp;#39;) // &amp;#39;a&amp;#39; string_diff(&amp;#39;coding&amp;#39;, &amp;#39;ingcod&amp;#39;) // &amp;#39;&amp;#39; Potential Optimisations Instead of using counter we can a single dictionary with occurences in s incrementing the number and occurences in t decrementing it. Such as first unique character.</description></item><item><title>First Unique Character</title><link>https://mohkale.gitlab.io/exercises/first-unique-character/</link><pubDate>Tue, 14 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/first-unique-character/</guid><description>Test Cases firstUniqueChar(&amp;#34;abcabd&amp;#34;) // 2 firstUniqueChar(&amp;#34;thedailybyte&amp;#34;) // 1 firstUniqueChar(&amp;#34;developer&amp;#34;) // 0</description></item><item><title>Valid Anagram</title><link>https://mohkale.gitlab.io/exercises/valid-anagram/</link><pubDate>Mon, 13 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/valid-anagram/</guid><description>Test Cases IsAnagram([]rune(&amp;#34;cat&amp;#34;), []rune(&amp;#34;tac&amp;#34;)) // true IsAnagram([]rune(&amp;#34;listen&amp;#34;), []rune(&amp;#34;silent&amp;#34;)) // true IsAnagram([]rune(&amp;#34;program&amp;#34;), []rune(&amp;#34;function&amp;#34;)) // true Alternative Implementation An implementation with a larger time complexity but no space complexity is also possible. We can simply sort both strings and compare them to each other. If their anagrams then their sorted output must be equal.
func sortRunes(str []rune) { sort.Slice(str, func(i, j int) bool { return str[i] &amp;lt; str[j] }) } func IsAnagram(str, rts []rune) bool { if len(str) !</description></item><item><title>Jewels and Stones</title><link>https://mohkale.gitlab.io/exercises/jewels-and-stones/</link><pubDate>Sun, 12 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/jewels-and-stones/</guid><description>Test Cases jewel_count(&amp;#34;ac&amp;#34;, &amp;#34;abc&amp;#34;) # 2 jewel_count(&amp;#34;AaaddfFf&amp;#34;, &amp;#34;Af&amp;#34;) # 3 jewel_count(&amp;#34;AYOPD&amp;#34;, &amp;#34;ayopd&amp;#34;) # 0 Alternative Implementation Convert the jewel string to a set \(\mathcal{O}(j)\) and then for each character in the stones string, count if its in the jewel set. Checking for the presence of a string in a set takes \(\mathcal{O}(1)\) time so total time complexity adds up to \(\mathcal{O}(j+s)\)
def jewel_count(stones, jewels): return sum(1 for s in stones if s in set(jewels))</description></item><item><title>Two Sum</title><link>https://mohkale.gitlab.io/exercises/two-sum/</link><pubDate>Sat, 11 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/two-sum/</guid><description>Proof The improvement here is dependent on the nature of sums. Take for example the naive implementation of summing each value across the array twice to form a 2D matrix.
fun twoSum(ts: IntArray, k: Int): Boolean { for ((i, a) in ts.withIndex) { for ((j, b) in ts.withIndex) { if (i != j &amp;amp;&amp;amp; a + b == k) { return true } } } return false } With an array of [1, 2, 3, 4] we construct the following summation matrix using our above implementation.</description></item><item><title>Longest Common Prefix</title><link>https://mohkale.gitlab.io/exercises/longest-common-prefix/</link><pubDate>Thu, 09 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/longest-common-prefix/</guid><description>Proof Observe that each recursive invocation of recursive_lcp either ends the recursion or cuts the search space in half. Also observe that there's a finite number of possible lengths for the longest common prefix. Therefore the algorithm must eventually converge on a prefix shared by every string in strs
Expanded Implementation The above solution can be just as well implemented without recursion like so:
def lcp(strs): longest = 0 lower, upper = 0, min(len(a) for a in strs) while upper &amp;gt; lower: mid = max((upper - lower) // 2, lower) if is_prefix(strs, mid): longest = mid lower = mid+1 else: upper = mid-1 return strs[0][:longest] Possible Improvements When we've found a valid prefix but not yet ended the loop, we don't need to keep comparing the substring of entries from lower to mid.</description></item><item><title>Capitalization Check</title><link>https://mohkale.gitlab.io/exercises/capitalisation/</link><pubDate>Tue, 07 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/capitalisation/</guid><description>Test Cases &amp;#34;USA&amp;#34;.capitalized? #=&amp;gt; true &amp;#34;Calvin&amp;#34;.capitalized? #=&amp;gt; true &amp;#34;compUter&amp;#34;.capitalized? #=&amp;gt; false &amp;#34;coding&amp;#34;.capitalized? #=&amp;gt; true</description></item><item><title>Variance in Java</title><link>https://mohkale.gitlab.io/posts/2020/07/07/variance-in-java/</link><pubDate>Tue, 07 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/07/07/variance-in-java/</guid><description>Variance is a cool sounding word I've always had difficulty wrapping my head around. I recently decided to start learning kotlin and in doing so I brushed up against java and type generics again. Now I think I finally have a good handle on it so lets try explaining variance in java.
The Syntax To start let's clarify how java represents generics syntactically.
List&amp;lt;String&amp;gt; strings; Here I've declared the variable strings to be a List which holds instances of the type String.</description></item><item><title>Vacuum Robot Route</title><link>https://mohkale.gitlab.io/exercises/vacuum-route/</link><pubDate>Mon, 06 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/vacuum-route/</guid><description>Test Cases routeIsCycle(&amp;#34;LR&amp;#34;) // =&amp;gt; true routeIsCycle(&amp;#34;URURD&amp;#34;) // =&amp;gt; false routeIsCycle(&amp;#34;RUULLDRD&amp;#34;) // =&amp;gt; true</description></item><item><title>Check Palindrome</title><link>https://mohkale.gitlab.io/exercises/check-palindrome/</link><pubDate>Sun, 05 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/check-palindrome/</guid><description>Proof Loop Invariant: At the end of each iteration of the loop, the characters \(i\) places from the start of the string is the same as the character at index \(i\) places from the end of the string, or the function returns False.
At the beginning of the loop \(i=0\) and \(l-i-1=l-1\) which is the index of the last character of the string. If these two are equal the loop continues, otherwise the loop ends and the function returns False.</description></item><item><title>Reversing a String</title><link>https://mohkale.gitlab.io/exercises/reversing-a-string/</link><pubDate>Sat, 04 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/exercises/reversing-a-string/</guid><description>Proof Loop Invariant: at the end of each iteration of the loop, the character at index \(i\) and the character at index \(l-i-1\) is at its correct position in the reversed string.
Let \(m\) be the middle of the string. This is equal to \(floor(len(s)/2)\).
In the first iteration \(i=0\). The first character (\(0\)) is moved to the end of the string and the last character (\(l-i-1\)) is moved to the start of the string.</description></item><item><title/><link>https://mohkale.gitlab.io/notes/go/</link><pubDate>Fri, 03 Jul 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/notes/go/</guid><description>// go supports both inline and /* multiline comments */ /* the `go fmt` command reads go code and uses it to build documentation for a go project. Some file in each package should have a doc comment at the start of it to describe the package. Similarly each public struct or function should also have a documentation comment. */ // package declarations come before any imports. package main /* Each package is a collection of files in the same directory.</description></item><item><title>Gradle</title><link>https://mohkale.gitlab.io/notes/gradle-kts/</link><pubDate>Sat, 25 Apr 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/notes/gradle-kts/</guid><description>gradle is a build framework implemented in java. It has supports both groovy and kotlin for defining build tasks. Before you venture any further, it's probably worth taking a look at my Kotlin language notes (if you're not familliar with the language), because that's the preferred build DSL for this guide.
gradle is implemented using the following configuration files:
File Description build.gradle the script file in which tasks are implemented gradle.</description></item><item><title>Decorators Are Awesome!</title><link>https://mohkale.gitlab.io/posts/2020/04/01/decorators-are-awesome/</link><pubDate>Wed, 01 Apr 2020 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/2020/04/01/decorators-are-awesome/</guid><description>As my first post on this blog, I wasn't sure what to write on. I'd prefer something not too long, simple, and informative. After enough time, I decided I may as well just talk about a feature of python I absolutely love ❤️. So let's discuss decorators.
First Class Objects Before that however, we should build some background. Python supports the concept of functions as first class objects. What this means, in relation to our current topic, is that a function can be passed to another function, and a function can be returned from another function.</description></item><item><title>3-Tier Architecture</title><link>https://mohkale.gitlab.io/brain/20210908023943-3_tier_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210908023943-3_tier_architecture/</guid><description>The most common architectural design for [see page 13, information systems].
Built top down with clear separation between the user interface, business logic and data storage. Can come in open and closed varieties, where closed has each layer only able to communicate to neighbouring layers and open allows each layer to talk to any other layer.
\begin{figure} \centering \begin{tikzpicture}[line/.style={very thick, dashed}] \begin{umlpackage}{Presentation Layer}\end{umlpackage} \begin{umlpackage}[right=1cm of Presentation Layer]{Processing Layer}\end{umlpackage} \begin{umlpackage}[right=1cm of Processing Layer]{Storage Layer}\end{umlpackage} \draw [line, dashed, -&amp;gt;, transform canvas={yshift=0.</description></item><item><title>3D Representations</title><link>https://mohkale.gitlab.io/brain/20201008155604-3d_representations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201008155604-3d_representations/</guid><description>.org-center { margin-left: auto; margin-right: auto; text-align: center; } Computer [see page 2, [graphics](COM3503-w03-3d-obj-repr)] was born when Ivan Sutherland had the idea that geometry is **Structured Data** (Kajiya, 92). There are many approaches:
Polygons parametric patches CSG space subdivision implicit representation See [see page 28, here] for a list of considerations to take into account when choosing one representation over another.
Designing 3D Models There's [see page 22, numerous] ways to design 3D models:</description></item><item><title>3D Texture Mapping</title><link>https://mohkale.gitlab.io/brain/20201120185749-3d_texture_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120185749-3d_texture_mapping/</guid><description>Applying a texture to a complex 3D object.
We do this by [see page 3, creating] a volume of colors and applying them to an objects surface.
See here... cool 😎.</description></item><item><title>4-Tier Architecture</title><link>https://mohkale.gitlab.io/brain/20210908030125-4_tier_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210908030125-4_tier_architecture/</guid><description>A useful architectural style for Object Oriented [see page 14, Systems].
It subdivides the middle tier of 3-tier architecture with business rules controlling cclasses used by this application only and business model modelling classes common to several applications. This is a good style for software reuse.
\begin{figure} \centering \begin{tikzpicture}[line/.style={very thick, dashed}] \begin{umlpackage}{User Interface}\end{umlpackage} \begin{umlpackage}[right=0.5cm of User Interface]{Business Rules}\end{umlpackage} \begin{umlpackage}[right=0.5cm of Business Rules]{Business Model}\end{umlpackage} \begin{umlpackage}[right=0.5cm of Business Model]{Persistent Storage}\end{umlpackage} \draw [line, dashed, -&amp;gt;, transform canvas={yshift=0.</description></item><item><title>404 Page Not Found</title><link>https://mohkale.gitlab.io/404/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/404/</guid><description>.info { display: flex; justify-content: center; font-size: 3em; text-align: center; } ¯\_(ツ)_/¯ Page Not Found</description></item><item><title>4th Generation Languages</title><link>https://mohkale.gitlab.io/brain/20220102171038-4th_generation_languages/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220102171038-4th_generation_languages/</guid><description>Languages designed for specific applications like NOMAD for report generation, SQL for database queries and postscript for report generation.</description></item><item><title>5th Generation Languages</title><link>https://mohkale.gitlab.io/brain/20220102171121-5th_generation_languages/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220102171121-5th_generation_languages/</guid><description>Still somewhat nuanced, but has been referred to for languages using logic and constraint based problem solving like Prolog.</description></item><item><title>About</title><link>https://mohkale.gitlab.io/about/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/about/</guid><description/></item><item><title>Absorption Costing</title><link>https://mohkale.gitlab.io/brain/20201106013354-absorption_costing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106013354-absorption_costing/</guid><description>The [see page 12, method] used to obtain the full cost of a product or service.
This cost is used for inventory valuation in the annual report and can be used as a basis for determine [see page 14, product price] for a price-setter product.
Takes into account:
Competitive and market conditions. Non-manufacturing overheads. Desired return. \[ \text{Cost} + \text{Mark Up} = \text{Selling Price} \]
See actual process [see page 14, here] and see example see page 18, here.</description></item><item><title>Abstract Class</title><link>https://mohkale.gitlab.io/brain/20210924022102-abstract_class/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210924022102-abstract_class/</guid><description>Is a class so [see page 3, general] that you would never create any direct instances of it, generally such classes contain abstract operations which can be named but not described algorithmically.
Abstract classes are modelled the same as regular classes except with the class name being italic and any abstract methods also being italic.
Interface Is an extension of abstract classes where every method is abstract.
Interfaces can be drawn as classes with the &amp;lt;&amp;lt;interface&amp;gt;&amp;gt; tag or as just a plain circle with the interface name (this is known as the overview style).</description></item><item><title>Abstract Factory Pattern</title><link>https://mohkale.gitlab.io/brain/20210922052437-abstract_factory_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922052437-abstract_factory_pattern/</guid><description>Is a software design pattern where components that are dependent upon each other are encapsulated and accessed through a factory class. The classical example for the factory pattern is Swings pluggable UI where functions for drawing a scroll-bar, window, and other components is encapsulated in a theme factory which can be passed to the renderer.
This pattern provides generic creation of objects [see page 24, indicating] generic behaviour.</description></item><item><title>Acceptance</title><link>https://mohkale.gitlab.io/brain/20201018223004-acceptance/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018223004-acceptance/</guid><description>A party accepts an offer in a contractual negotiation. Acceptance must be:
Absolute and Unequivocal - varying the terms or counter-offering is not acceptance. Communicated to the offerer - Either vocally, through text or through an action, silence (defined as not saying anything AND not doing anything) isn't sufficient. Only the final offer presented is considered active, responding with a counter-offer destroys the original offer and it must be offered again to be acceptable.</description></item><item><title>Acceptance Criteria</title><link>https://mohkale.gitlab.io/brain/20210626234252-acceptance_criteria/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234252-acceptance_criteria/</guid><description>Are a set of [see page 20, statements] with clear pass/fail results. These form the basis of acceptance testing.
For [see page 19, example] with the story card &amp;quot;As a user I want to cancel my order&amp;quot;, we must have acceptance criteria outlining does the user get a full or partial refund?, how far in advance must the order be cancelled?, does the user get a confirmation etc.
Be careful to [see page 23, distinguish] acceptance criteria from scenarios.</description></item><item><title>Acceptance Tests</title><link>https://mohkale.gitlab.io/brain/20210626232538-acceptance_tests/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626232538-acceptance_tests/</guid><description>Are tests specified by the [see page 44, client] of a software system. They show that the system meets the requirements needed by the client.
These [see page 46, tests] don't all have to pass to accept new code into the code-base (like is common with CI), in fact the ratio of passing to failing tests can be used to measure the project-velocity (sum of story-points over iteration). I.E. What percentage of the customers acceptance test cases pass?</description></item><item><title>Access Control</title><link>https://mohkale.gitlab.io/brain/20210211060415-access_control/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211060415-access_control/</guid><description>Controlling access of system entities on behalf of subjects to objects based on a access control policy.</description></item><item><title>Access Control Matrix Model</title><link>https://mohkale.gitlab.io/brain/20210211222446-access_control_matrix_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211222446-access_control_matrix_model/</guid><description>An ACM that's [see page 26, defined] in terms of the privileges of subjects on objects.
Term Description Subjects People who interact with the system Objects Things that subjects can interact with Privileges The rights a subject has on a model We define a protection state \( P \) as a triple \( (S,O,M) \), with:</description></item><item><title>Access Control Model</title><link>https://mohkale.gitlab.io/brain/20210211221833-access_control_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211221833-access_control_model/</guid><description>[see page 22, Oversees] the permissions a user has and the interactions they can perform with various objects in a system, essentially enforces the access control policy. Typical models focus on authorisation:
Who is allowed to do what? How do you update/change the system \[ \text{Subject} \times \text{Object} \times \text{Request} \]
Note: A [see page 24, policy] defines what you want to do, a model describes how you implement a policy.</description></item><item><title>Accounting</title><link>https://mohkale.gitlab.io/brain/20201011162619-accounting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201011162619-accounting/</guid><description>.org-center { margin-left: auto; margin-right: auto; text-align: center; } The process of identifying, measuring and **communicating economic** information to permit informed judgements and decisions by users of information. Bookkeeping - Accounting of financial transactions. The common approach is [see page 17, double-entry-accounting system].
Financial Accounting Financial accounting - meant for those external to the organisations who need to get a view inside (eg. Investors, Creditors, Tax Authorities, Suppliers and Employees).</description></item><item><title>ACID</title><link>https://mohkale.gitlab.io/brain/20201127014556-acid/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127014556-acid/</guid><description>Refers to a core aspect of DBMS.
Term Meaning Atomic Part of transaction failing =&amp;gt; all transaction fails. Consistent Each transaction moves from a valid state to another valid state. Can't currupt db. Isolated Transactions are consistent regardless of the order in which their run. Durable Data persists on the disk. Note: Grouping multiple transactions and running them concurrently has the same affect as running each transaction independently.</description></item><item><title>Acid Test Ratio</title><link>https://mohkale.gitlab.io/brain/20210113044551-acid_test_ratio/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210113044551-acid_test_ratio/</guid><description>Indicates the time lag in turning inventory into cash.
\[ \frac{\mathrm{Current Assets} - \mathrm{Inventory}}{\mathrm{Current Liabilities}} \]</description></item><item><title>Acoustic Echo</title><link>https://mohkale.gitlab.io/brain/20201127205928-acoustic_echo/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127205928-acoustic_echo/</guid><description>Refers to the phenomena where output from a speaker may then be picked up by the microphone and then transmitted back to the sender.
That is to say a person speaking into a phone may end up hearing their own voice echoed back to them after travelling to the receiver and then returning.</description></item><item><title>Acoustic Echo Canceler</title><link>https://mohkale.gitlab.io/brain/20201127205913-acoustic_echo_canceler/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127205913-acoustic_echo_canceler/</guid><description>Reduces the amplitude of Acoustic Echo responses.
We essentially form an Adaptive Filter with a bunch of weighted [see page 5, coefficients] that cancels out the acoustic echo response before transmission. The problem of acoustic echo cancellation is finding the weights at time \( n \) which cancels the current acoustic echo response.
Note: In this situation we have to use an adaptive filter because the acoustic echo response varies over time and so a filter with constant coefficients can't accurately remove acoustic echos.</description></item><item><title>Acoustic Phonetics</title><link>https://mohkale.gitlab.io/brain/20201020212222-acoustic_phonetics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020212222-acoustic_phonetics/</guid><description>A description of speech sounds in terms of the acoustic consequence of their production.
A study on the [see page 3, production of vowels] and the associated first and second Formants shows that that their a [see page 6, direct correlation] between these formants and the vowel quadrilateral. We can construct the vowel space as a graph listing the frequencies of the first and second formants and [see page 7, plot] where we expect different vowels to show up.</description></item><item><title>Activity Diagram</title><link>https://mohkale.gitlab.io/brain/20210701011715-activity_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701011715-activity_diagram/</guid><description>Is a UML flow based process-view diagram.
The structure of an activity diagram is the same as a state machine diagram, making it easy to confuse the two.
Table 1: Listing of the core see page 22, [differences] between state and activity diagrams. Activity Diagram State Machine Diagram All the activity happens in the nodes. All the activity happens on the transitions. The flows just represent transfer of control.</description></item><item><title>Actor</title><link>https://mohkale.gitlab.io/brain/20210911021535-actor/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911021535-actor/</guid><description>An actor is something that can act, a person, system or organisation. This doesn't relate to a specific person but the role they play, meaning a single person can portray multiple actors/roles.
Actors are drawn in UML as stick-men with the role below their name. \tikz \umlactor[scale=0.5]{User};</description></item><item><title>Acyclic Graph</title><link>https://mohkale.gitlab.io/brain/20210628025719-acyclic_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628025719-acyclic_graph/</guid><description>Is a graph with no cycles.</description></item><item><title>Adaptive Filter</title><link>https://mohkale.gitlab.io/brain/20201127211454-adaptive_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127211454-adaptive_filter/</guid><description>A filter which changes it's frequency-response over time.
Adaptive filters are defined in terms of weights which they apply to the current input (depending on the previous output). For an adaptive filter these weights are always changing (adapting) to the input it receives meaning the frequency response of the filter is also always changing.
They have [see page 4, a tonne] of applications.</description></item><item><title>Adaptive Intelligence</title><link>https://mohkale.gitlab.io/brain/20210206033935-adaptive_intelligence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206033935-adaptive_intelligence/</guid><description>An innate [see page 2, ability] to use information to educate yourself on the surroundings and climate. Most humans can do this from birth. Put simply brains cause minds.
Adaptive intelligence is underpinned by the [see page 5, belief] that better understanding of the biological brains could play a vital role in building intelligent machines.
If a known algorithm is subsequently found to be implemented in the brain, then that is strong support for its plausibility as an integral component of an overall general intelligence system.</description></item><item><title>Adaptive Modelling</title><link>https://mohkale.gitlab.io/brain/20201029200738-adaptive_modelling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201029200738-adaptive_modelling/</guid><description>Is an approach to building a model for text compression where we build the model and apply it to compression in the same pass.
Method To Encode:
Begins with a base probability distribution. Refines the model as symbols are encountered (the text redefines the model). To Decode:
Decoder starts with the same PD. Decoder is decoding the same symbol sequence so it can refine in the same way.</description></item><item><title>Adaptive Tree Depth Control</title><link>https://mohkale.gitlab.io/brain/20210106003909-adapive_tree_depth_control/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106003909-adapive_tree_depth_control/</guid><description>An [see page 17, optimisation technique] for recursive ray-tracing intersection detection, which terminates the recursion once the contribution of the next recursive call falls below a certain threshold.</description></item><item><title>Address Space Layout Randomisation</title><link>https://mohkale.gitlab.io/brain/20211010230430-address_space_layout_randomisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010230430-address_space_layout_randomisation/</guid><description>Is a compile-time feature which causes a important sections of a processes address space, including the base address of the executable and the position of the stack, heap, and libraries, to start at randomised values on every run.</description></item><item><title>Adjacency List</title><link>https://mohkale.gitlab.io/brain/20210628054948-adjacency_list/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054948-adjacency_list/</guid><description>Is a way to [see page 3, store] a graph, where each vertex keeps a linked-list of all the vertices its connected to.
These are more compact and [see page 6, preferable] for sparse graph.
Determining whether there's an edge between two vertices can take up to \( \Omega(|v|) \).</description></item><item><title>Adjacency Matrix</title><link>https://mohkale.gitlab.io/brain/20210628055038-adjacency_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628055038-adjacency_matrix/</guid><description>Is a way to [see page 3, store] a graph, where we maintain a \( |V| \times |V| \) matrix and if an edge between two vertices \( i \) and \( j \) exist then \( M[i,j] = 1 \).
Determining whether there's an edge between two vertices takes linear time \( \O(1) \).</description></item><item><title>Adjoint Matrix</title><link>https://mohkale.gitlab.io/brain/20210621222944-adjoint_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621222944-adjoint_matrix/</guid><description>The adjoint matrix of a matrix \( A \) is the transpose of its co-factor matrix.
For a 2x2 matrix this is
\begin{align*} A &amp;amp;=
\begin{pmatrix} a &amp;amp; b \\\\ c &amp;amp; d \end{pmatrix} \\\\ adj(A) &amp;amp;=
\begin{pmatrix} d &amp;amp; -b \\\\ -c &amp;amp; a \end{pmatrix} \end{align*}</description></item><item><title>Advanced Ray Tracing</title><link>https://mohkale.gitlab.io/brain/20210106021136-advanced_ray_tracing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106021136-advanced_ray_tracing/</guid><description>Try to approximate the rendering-equation by sending out [see page 12, many, many] rays from each intersection point. But tracing this many rays approach isn't practical.</description></item><item><title>Agent</title><link>https://mohkale.gitlab.io/brain/20210926212456-agent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926212456-agent/</guid><description>An [see page 24, agent] is anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators.
Note: An agent need not be physical. A software agent receives keystrokes, file contents, and network packets as sensory inputs and act on the environment by displaying on the screen, writing files sand sending network packets.</description></item><item><title>Agent Function</title><link>https://mohkale.gitlab.io/brain/20210926222606-agent_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926222606-agent_function/</guid><description>The mathematical representation of an agents decision process, mapping from a percept sequence to an action.</description></item><item><title>Agent Program</title><link>https://mohkale.gitlab.io/brain/20210926222653-agent_program/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926222653-agent_program/</guid><description>A concrete implementation of the Agent Function in a physical system.</description></item><item><title>Aggregation</title><link>https://mohkale.gitlab.io/brain/20210911020557-aggregation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911020557-aggregation/</guid><description>Is a relationship between two entities expressing a [see page 23, whole-parts] relationship. If the whole is broken down the parts continue to exist.
\begin{figure} \centering \begin{tikzpicture} \umlclass{Bicycle}{ serialNumber: Integer \\ brand: String}{}; \umlclass[x=7]{Wheel}{ diameter: Integer \\ tyrePressure: Real}{}; \umlsimpleclass[x=-1, y=-3]{Fork}; \umlsimpleclass[x=1, y=-3]{Frame}; \umlVHVaggreg[pos2=2.8, attr2=fork|1]{Bicycle}{Fork}; \umlVHVaggreg[pos2=2.8, attr2=frame|1]{Bicycle}{Frame}; \umlaggreg[attr2=wheels|2]{Bicycle}{Wheel}; \end{tikzpicture} \caption{Example of an aggregation relationship. If the bicycle stops existing the individual parts it&amp;#39;s made up of will continue to exist therefore it&amp;#39;s an aggregation.</description></item><item><title>Agile Software Development</title><link>https://mohkale.gitlab.io/brain/20210626220855-agile_software_development/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626220855-agile_software_development/</guid><description>A software development manifesto that values:
Individuals and Interaction over processes and tools. Working software over comprehensive documentation. Customer collaboration over contract negotiations. Responding to change over following a plan. Agile development is fast, reactive and generally nicer to programmers.
See the core principles behind the agile manifesto.
See the [see page 21, advantages &amp;amp; disadvantages].
Agile processes [see page 33, deviate] from the traditional method by:
Having no BDUF (Big Design Up Front).</description></item><item><title>Algebra</title><link>https://mohkale.gitlab.io/brain/20210627010050-algebra/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010050-algebra/</guid><description>[see page 20, Consists] of a set of elements/values, at least one operation over these values and some laws for the behaviour of the operations.</description></item><item><title>Algorithm</title><link>https://mohkale.gitlab.io/brain/20210622170854-algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622170854-algorithm/</guid><description>A set of precise [see page 3, instructions] which when followed in order will take some input and produce some output solving a problem.</description></item><item><title>Alice and Bob</title><link>https://mohkale.gitlab.io/brain/20210430004411-alice_and_bob/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430004411-alice_and_bob/</guid><description>Many [see page 35, discussions] of security begin with Alice, Bob and Eve.
Are three individuals who're often referenced in examples related to cryptography and system security. This is a convention.
Alice and Bob could be 2 devices/people/lovers who want to communicate securely. Eve is an intruder who tries to intercept, delete or modify messages between Alice and Bob.</description></item><item><title>All Posts</title><link>https://mohkale.gitlab.io/posts/all/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/posts/all/</guid><description/></item><item><title>Allophone</title><link>https://mohkale.gitlab.io/brain/20201026220839-allophone/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026220839-allophone/</guid><description>The set of different phones which make up a given phoneme. See examples [see page 5, here].
For example [l] as in wall is phonetically different to [l] in light. These variants are both allophones of l.
The distribution of allophones in a language is based on how different phonetic features achieve the same phonemic contrast.</description></item><item><title>Amplitude Quantisation</title><link>https://mohkale.gitlab.io/brain/20210130021430-amplitude_quantisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130021430-amplitude_quantisation/</guid><description>Quantisation of a signals amplitude at a given point in time.
We define the [see page 4, dynamic range] as the range of numbers that can be used to represent a signals amplitude.
If we use \(n\) bits with \(2^{n-1}\) possible values we have a dynamic range in dB of: \[ 20 log_{10}(2^{n-1}) \]
We often use a dynamic range of \(16 \mathrm{\;bits} = 65535 \mathrm{\; possible\;values} = 96 \mathrm{\;dB}\)</description></item><item><title>Animation</title><link>https://mohkale.gitlab.io/brain/20201124161238-animation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201124161238-animation/</guid><description>Showing a bunch of pictures quickly to make them seem moving.
[see page 3, Modern] approaches to animation involves changing an objects state (join, vector, color, coordinate) over time. This is most often done with something like parametric-curves.
[see page 5, Models] Animation is divided into [see page 4, levels] depending on how many parameters and how much control we have over the animation.
Model Level Meaning Descriptive low Effect without knowledge of cause (depends on Degrees of Freedom).</description></item><item><title>Anti Aliasing</title><link>https://mohkale.gitlab.io/brain/20201027211330-anti_aliasing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027211330-anti_aliasing/</guid><description>A series of visual artefacts produced while Sampling images.
You can [see page 2, visualise] this problem as trying to reconstruct continuous world-space coordinates in discrete screen-space coordinates while maintaining a recognisable image even at low resolutions.
Aliasing causes the following rendering artefacts:
Moire Patterns Scintillation Crawling .org-center { margin-left: auto; margin-right: auto; text-align: center; } An alias is a signal travelling in disguises as another frequency. This is an issue when sampling a signal at a lower frequency than it's actual frequency, causing us to miss some values in the signal.</description></item><item><title>Anti Hebbian Rules</title><link>https://mohkale.gitlab.io/brain/20210218021815-anti_hebbian_rules/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218021815-anti_hebbian_rules/</guid><description>Refers to a class of learning-rules which contain a negative minimal hebbian rule.
For example the formula \[ \Delta{w_{ij}} = - \alpha v_i v_j \] is a anti hebbian rule because it quite literally weakens the synaptic connection between neurons when they fire together often.</description></item><item><title>Anti-Forensics</title><link>https://mohkale.gitlab.io/brain/20210415004532-anti_forensics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415004532-anti_forensics/</guid><description>Tools and techniques designed to [see page 8, disrupt] a digital-forensic investigations.
The goals here are to:
Hide data from an investigator Disrupt information collection Increase the time required to carry out analysis Introduce doubt to the investigation findings Subvert the tools used during the investigations Leave no evidence of anti-forensics techniques For example planting data into a file such that when it's loaded into an analysis tool it crashes the tool.</description></item><item><title>Anti-Symmetric Relation</title><link>https://mohkale.gitlab.io/brain/20210627012939-anti_symmetric_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627012939-anti_symmetric_relation/</guid><description>A property of a relation \( R \subseteq A \times B \) where no pair of distinct elements of \( X = A \times B \) each of [see page 20, which] is related by \( R \) to the other.
\begin{align*} \forall a \in A, b \in B ((a R b) \implies a = b) \
\forall a \in A, b \in B ((a R b) \land (a \neq b) \implies \neg (b R a)) \end{align*}</description></item><item><title>AP-Algorithm</title><link>https://mohkale.gitlab.io/brain/20210107215817-apa_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210107215817-apa_algorithm/</guid><description>The fastest known Gradient Algorithm for acoustic-echo-cancellation, which takes the [see page 17, same form] as the NLMS-algorithm except it uses Vector error instead of scalar and a Matrix signal, not a vector signal. Note: At a high level you can conclude AP Converges faster than LMS because it searches in more dimensions.
If the number of dimensions used by AP is 1, then AP is exactly equivalent to NLMS.</description></item><item><title>Approximation</title><link>https://mohkale.gitlab.io/brain/20210216015820-approximation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216015820-approximation/</guid><description>Refers to an approximate characterisation of some-substitution system.
For example [see page 7, this] S-box is shown to have 3-approximations based on 3 linear-expressions.
End to End Approximation We define the E2E approximation as the bits in a binary value that're all XORed together in a linear-expression.</description></item><item><title>Arbitration</title><link>https://mohkale.gitlab.io/brain/20210120044906-arbitration/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210120044906-arbitration/</guid><description>A way for two conflicted parties to settle a dispute using a third party [see page 16, arbitrator].</description></item><item><title>Arithmetic Coding</title><link>https://mohkale.gitlab.io/brain/20201029212041-arithmetic_coding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201029212041-arithmetic_coding/</guid><description>A coding algorithm which is suitable for images. This approach is:
Slower than Huffman coding. Not easy to start decoding in the middle of a compressed stream. Less suitable for full-text retrieval (random access required). Procedure Arithmetic coding [see page 26, represents] our encoded input as a fractional binary number. We build a model containing the probabilities of each character in our alphabet and place it on a number line (from 0-1).</description></item><item><title>Arithmetic Series</title><link>https://mohkale.gitlab.io/brain/20210621183201-arithmetic_series/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621183201-arithmetic_series/</guid><description>A type of series where the value of the next entry is equal to the current entry plus some constant.
Given the first value in the series \( a \) and the constant by which it changes \( d \), you can define the value of an element at any index in the series as
\begin{align} \label{eq:arithmetic-formula} U_n = a + (n-1)d \end{align}
All arithmetic series follow eq:arithmetic-formula.
We can define the sum of the first \( n \) elements of an arithmetic series as:</description></item><item><title>Arrays as Trees</title><link>https://mohkale.gitlab.io/brain/20210628052524-arrays_as_trees/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628052524-arrays_as_trees/</guid><description>You can represent any contiguous array of elements as a binary-tree where:
\begin{align} \text{Parent}(i) &amp;amp;= \lfloor \frac{i}{2} \rfloor \
\text{Left}(i) &amp;amp;= 2i \
\text{Right}(i) &amp;amp;= 2i + 1 \end{align}
Figure 1: Visualisation of the relation between an array and a tree.</description></item><item><title>Articulators</title><link>https://mohkale.gitlab.io/brain/20201020202757-articulators/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020202757-articulators/</guid><description>Articulators are the [see page 3, parts] of the mamalian vocal system which change shape to alter resonant characteristics. For example the tongue is an articulator.
Articulators can either be active (eg. the tongue) or passive (eg. the top of the mouth).</description></item><item><title>Articulatory Phonetics</title><link>https://mohkale.gitlab.io/brain/20201020144023-articulatory_phonetics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020144023-articulatory_phonetics/</guid><description>A description of speech sounds in terms of the physical actions performed in their production. This mostly just involves [see page 4, classifying] sounds based on how vocal-tract is modified.
Note: All sounds are either consonants or Vowels.
Consonants Articulatory phonetics can classify consonants based on the Voice-Place-Manner. This impacts the positioning of symbols in the [see page 11, IPA] language system, and we often label symbols based on VPM labels.</description></item><item><title>Artificial Intelligence</title><link>https://mohkale.gitlab.io/brain/20210926204334-artificial_intelligence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926204334-artificial_intelligence/</guid><description>An artificially intelligent being.
This has been [see page 22, assessed] in different ways across the history of AI:
Thinking Humanly Machines with minds in the full and literal sense. The automation of activities that we associate with human thinking (decision making, problem solving, learning, ...). Thinking Rationally The study of mental faculties through the use of computational models. The study of the computations that make it possible to perceive, reason and act.</description></item><item><title>Artificial Neurons</title><link>https://mohkale.gitlab.io/brain/20210206060941-artificial_neurons/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206060941-artificial_neurons/</guid><description>A mathematical model of the neuron.
Excitation The excitation equation follows the same form as a regular neuron, just with some of the fields being named differently.
\begin{align} h_i &amp;amp;= \sum_{j}{{w}_{ij} \times x_j} \
y_i &amp;amp;= f(h_i) \end{align}
Matrix Notation Observe that we have a collection of input neurons which we enumerate using the \( j \) variable. We multiply each input with a corresponding weight of the connection to that neuron and sum the result.</description></item><item><title>Ascii</title><link>https://mohkale.gitlab.io/brain/20210717004310-ascii/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717004310-ascii/</guid><description>The American Standard Code for Information Interchange, is a character encoding scheme.
Table 1: The 127 code points of unicode in the 8x4 given in most references. 00 NUL 10 DLE 20 30 0 40 @ 50 P 60 ` 70 p 01 SOH 11 DC1 21 ! 31 1 41 A 51 Q 61 a 71 q 02 STX 12 DC2 22 &amp;quot; 32 2 42 B 52 R 62 b 72 r 03 ETX 13 DC3 23 # 33 3 43 C 53 S 63 c 73 s 04 EOT 14 DC4 24 $ 34 4 44 D 54 T 64 d 74 t 05 ENQ 15 NAK 25 % 35 5 45 E 55 U 65 e 75 u 06 ACK 16 SYN 26 &amp;amp; 36 6 46 F 56 V 66 f 76 v 07 BEL 17 ETB 27 ' 37 7 47 G 57 W 67 g 77 w 08 BS 18 CAN 28 ( 38 8 48 H 58 X 68 h 78 x 09 HT 19 EM 29 ) 39 9 49 I 59 Y 69 i 79 y 0A LF 1A SUB 2A * 3A : 4A J 5A Z 6A j 7A z 0B VT 1B ESC 2B + 3B ; 4B K 5B [ 6B k 7B { 0C FF 1C FS 2C , 3C &amp;lt; 4C L 5C *\* 6C l 7C 0D CR 1D GS 2D - 3D = 4D M 5D ] 6D m 7D } 0E SO 1E RS 2E .</description></item><item><title>Assembly</title><link>https://mohkale.gitlab.io/brain/20210930004328-assembly/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210930004328-assembly/</guid><description>Is the lowest level programming language, excluding writing 0s and 1s exactly.
Each computer has an architecture with an associated assembly language. Each assembly language command has a 1:1 mapping to a set of 1s or 0s that tells the computer what to do. For example add BYTE PTR [0x20], 1 assembly instruction from x86 assembly adds 1 to the memory address 20.
Atomic Operations Most modern architectures support atomic operations by prefixing the instruction with lock.</description></item><item><title>Assembly Languages</title><link>https://mohkale.gitlab.io/brain/20220102165645-assembly_languages/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220102165645-assembly_languages/</guid><description>Are programming languages one step ahead of machine language. Initially assembly instructions were just mnemonic short-codes for the equivalent machine instructions. Later support for macro-instructions were added to support parameterized shorthands for frequently used instructions (or subroutines).</description></item><item><title>Assets</title><link>https://mohkale.gitlab.io/brain/20210112040430-assets/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210112040430-assets/</guid><description>A [see page 23, resource] controlled by an entity from which economic benefits are expected to be received.
We can [see page 26, define]:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Assets = [Liabilities](/brain/20210112040528-liabilities/) + [Equity](/brain/20210112040622-equity/) Which can be interpreted as whatever the entity owns is funded by debt or the capital provided by its owners.
Assets can be [see page 28, classified] as: Current when their to be converted into cash, sold or consumed in 1 year or Operating Cycle (whichever is longer).</description></item><item><title>Association</title><link>https://mohkale.gitlab.io/brain/20210911021116-association/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911021116-association/</guid><description>Indicates a relationships between entities or classes.
\begin{figure} \centering \begin{tikzpicture} \umlclass{CurrentAccount}{ accountNumber: Integer \\ balance: Real \\ overdraftLimit: Real \\ holderForename: String \\ holderSurname: String \\ holderAddress: String }{ getBalance(): Real \\ deposit(amount: Real) \\ withdraw(amount: Real): Boolean }; \end{tikzpicture} \label{fig:assoc-eg-1} \caption{An example of a badly modelled class with attributes not dependent on the class itself.} \end{figure}\begin{figure} \label{fig:assoc-eg-2} \centering \begin{tikzpicture} \umlclass{CurrentAccount}{ accountNumber: Integer \\ balance: Real \\ overdraftLimit: Real \\ }{ getBalance(): Real \\ deposit(amount: Real) \\ withdraw(amount: Real): Boolean }; \umlclass[x=9]{Holder}{ forename: String \\ surname: String }{ getForename(): String \\ getSurname(): String \\ getAddress(): String }; \umlsimpleclass[x=9, y=-4]{Address}; \umlassoc[attr1=account|1.</description></item><item><title>Asymmetric Relation</title><link>https://mohkale.gitlab.io/brain/20210627013727-asymmetric_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627013727-asymmetric_relation/</guid><description>A property of a relation where any variable \( x \) that's related to another variable \( y \) implies that \( y \) is [see page 20, not] related back to \( x \) in the same way. \[ \forall a \in A, b \in B (a R b) \implies \neg (b R A) \]</description></item><item><title>Asymmetric-key Encryption</title><link>https://mohkale.gitlab.io/brain/20210215004614-asymmetric_key_encryption/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215004614-asymmetric_key_encryption/</guid><description>Is a Cryptographic System where knowledge of \( \text{Key1} \) cannot be used to easily derive \( \text{Key2} \).</description></item><item><title>Asymptotic Notation</title><link>https://mohkale.gitlab.io/brain/20210628050504-asymptotic_notation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628050504-asymptotic_notation/</guid><description>Is a way to measure the performance of an algorithm as a measure of its [see page 8, asymptotic growth]. The main observation with this approach is that as \( n \) grows the contribution of the smaller order terms quickly become irrelevant.
Asymptotic notation hides constant factors and small-order terms revealing asymptotic runtimes.
For example as \( n \) gets bigger the affect of \( +10n \) in \( 2n^2 + 10n \) can be mostly ignored.</description></item><item><title>Atomic Operations</title><link>https://mohkale.gitlab.io/brain/20210930012212-atomic_operations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210930012212-atomic_operations/</guid><description>Is an operation that no other processor can interrupt.
For example on a specific machine architecture if you run an assembly instruction to increment a register, that may be broken down into a few different steps on the circuity (example: fetching the value from memory -&amp;gt; storing in cache -&amp;gt; adding to it -&amp;gt; writing back). If these steps are split up between multiple processors or threads they could happen mismatch the result timing leading to writes that are lost or reads that are out of date.</description></item><item><title>Attenuation</title><link>https://mohkale.gitlab.io/brain/20201108013223-attenuation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201108013223-attenuation/</guid><description>Reducing the intensity of a point-light as the distance from it increases.
A common formula for this is defined as: \( F_{att}=\frac{1.0}{K_c + K_t * d + K_q * d^2} \)
We define \( d \) as the distance between the light source and fragment.
The remaining three variables are parameters configuring how attenuation should work:
\( k_c \) - a constant, often just one to make sure the denominator is &amp;gt; 1.</description></item><item><title>Audit</title><link>https://mohkale.gitlab.io/brain/20210112210933-audit/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210112210933-audit/</guid><description>An independent examination of the financial-statements that establish whether they show a true and fair view of the financial performance (profit) and position (value/worth) of the company.
Note: An audit doesn't guarantee the financial statements are correct.</description></item><item><title>Auditory Pathways</title><link>https://mohkale.gitlab.io/brain/20210129023615-auditory_pathways/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129023615-auditory_pathways/</guid><description>Describe where sound [see page 18, travels] after entering through the ears.</description></item><item><title>Authentication</title><link>https://mohkale.gitlab.io/brain/20210211060347-authentication/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211060347-authentication/</guid><description>Verifying the validity of something (usually the id claimed by a system entity).
Widely used [see page 17, mechanisms] for authentication are:
Mechanism Example Vulnerabilities Something you [see page 18, know] Password, PIN Short length can be guessed, phishing, and users can forget passwords Something you [see page 20, have] Smart-card, 1-time-password-generator If you lose the hardware you lose the ability to authenticate yourself Something you [see page 21, are] Biometrics Biometrics can change overtime (eg.</description></item><item><title>Authorisation</title><link>https://mohkale.gitlab.io/brain/20210211060359-authorisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211060359-authorisation/</guid><description>Granting (or denying) the right/permission of a entity to access a object. I.E. Specifying what a user can do.</description></item><item><title>Autocorrelation Function</title><link>https://mohkale.gitlab.io/brain/20201109230704-autocorrelation_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109230704-autocorrelation_function/</guid><description>Computes the correlation of a signal with itself (at a later or earlier point in time). Essentially a function that computes how similair a signal is at time \(i\) with that same signal at time \(i+n\) (for some number \(n\)).
Note: The only difference between this sum and the convolutional sum is that the signal in this case is reversed.
This [see page 16, function]:
is often quite expensive to compute.</description></item><item><title>Autoprobing</title><link>https://mohkale.gitlab.io/brain/20210717023912-autoprobing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717023912-autoprobing/</guid><description>Is the process of listening for commands at special memory addresses to discover available hardware devices adapting the kernel to your machine. This process is far from random with the kernel using a lot of built-in knowledge about what's likely to be found where and how controllers would respond if present.</description></item><item><title>Availability</title><link>https://mohkale.gitlab.io/brain/20201127003710-availability/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127003710-availability/</guid><description>Describes the expected uptime for a system over a certain period of time. For example the system must be available 364 days out of a year!.
We often measure availability as an annual percentage and commonly use the number of nines format. That is to say 5 nines means an availability of 99.999% out of a year. See more here.
For how availability varies in sequence and parallel systems, see here.</description></item><item><title>Availability</title><link>https://mohkale.gitlab.io/brain/20210211054131-availability/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211054131-availability/</guid><description>Ensuring that information is available (accessible) to authorised parties.</description></item><item><title>AVL Trees</title><link>https://mohkale.gitlab.io/brain/20210628054559-avl_trees/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054559-avl_trees/</guid><description>Is a self balancing binary search tree algorithm that works by rotating the tree after insertion and deletion operations to ensure it stays balanced.
In an AVL tree all nodes are locally balanced: The height of the left and right sub-trees [see page 4, differ] by at most 1. That is \( \text{bal}(v) = h(T_l) - h(T_r) \) where \( \text{bal}(v) \in \{ -1, 0, +1 \} \). This property is enforced by recording the height of a node in the node itself (to avoid having to repeatedly calculate it).</description></item><item><title>B+ Tree</title><link>https://mohkale.gitlab.io/brain/20210816164434-b_tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210816164434-b_tree/</guid><description/></item><item><title>Back Propagation</title><link>https://mohkale.gitlab.io/brain/20210208032640-back_propagation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210208032640-back_propagation/</guid><description>Is the [see page 16, application] of the previous outputs of a neural-network (forward pass) to refine the parameters of the network.
For a neural network we feed the information forwards to do our prediction, but for training we need to [see page 14, feed] the local-gradients backwards ([see page 16, back-propagation]).
Back-propagation is not very biologically plausible.
For
[see page 16, forward-propagation] all outputs are accumulated together from every neuron in the previous layer as input for a output-layer neuron All the output-layer (neurons) local-gradients goto a single hidden-layer neuron</description></item><item><title>Backdoor</title><link>https://mohkale.gitlab.io/brain/20210630231708-backdoor/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630231708-backdoor/</guid><description>Is a security vulnerability where developers leave secret routes or exploits in software for hackers to later exploit.</description></item><item><title>Bag of words</title><link>https://mohkale.gitlab.io/brain/20201014222521-bag_of_words/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201014222521-bag_of_words/</guid><description>An information retrieval model which records what words (terms) are present in a document alongside the number of times they appear. For example in a map structure from terms to counts.
Warn: This approach ignores the relation between words. eg. rabbit eating is vastly different to eating rabbit, but both have the same terms and term counts.</description></item><item><title>Baiting</title><link>https://mohkale.gitlab.io/brain/20210630235216-baiting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630235216-baiting/</guid><description>A social engineering attack where we leave infected flash drives or attack vectors in sight of victims; baiting them to attack themselves.</description></item><item><title>Band Analysis</title><link>https://mohkale.gitlab.io/brain/20201110183213-band_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110183213-band_analysis/</guid><description>Refers to how we can [see page 9, alter] the time/frequency resolution to better analyse what we're interested in, for example when running a fourier-transform.
See the graphical example [see page 10, here].
Narrowband analysis We have a larger number of samples (increase the analysis frame \(N\)).
This:
Decreases the spacing between spectral components. Reduces the ability to respond to changes in the signal. However it gives:
Affect Meaning Good spectral analysis Gives a good overview of important sections of the spectrogram.</description></item><item><title>Barrier</title><link>https://mohkale.gitlab.io/brain/20211007013230-barrier/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211007013230-barrier/</guid><description>Is a synchronisation primitive for threads. A barriers blocks the execution of one or more threads until all the threads reach the barrier. You can imagine this as a guard that prevents any thread that reaches it from continuing until all the other threads catch up.
The barrier is given a count when its initialised for the maximum number of threads it can block and then is called by each thread to block execution at a given point.</description></item><item><title>Batch</title><link>https://mohkale.gitlab.io/brain/20210305024920-batch/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210305024920-batch/</guid><description>A hyper-parameter specifying the number of samples to process in a learning algorithm before updating the model parameter (example: network weights).</description></item><item><title>Batch Gradient Descent</title><link>https://mohkale.gitlab.io/brain/20210305025507-batch_gradient_descent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210305025507-batch_gradient_descent/</guid><description>A variant of gradient descent where a single batch contains every sample in the training set.</description></item><item><title>Bayes Classifier</title><link>https://mohkale.gitlab.io/brain/20201125171151-bayes_classifier/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201125171151-bayes_classifier/</guid><description>A probabilistic approach to sentiment-analysis based on Bayes rule.
For this system we store our text as feature vectors and calculate the probability of each vector having a given sentiment, classifying the sentiment of the text to the most likely sentiment considered.
We see page 7, define: \(s^{*} = argmax_{s_i} p(s_i|T)\) for \(s_{i} \in \{negative, positive, neural\}\)
Where the:
Left hand side is the sentiment of the text \(T\) Right hand side calculates the probability of the text being one of the given sentiments.</description></item><item><title>BCM Rule</title><link>https://mohkale.gitlab.io/brain/20210301033856-bcm_theory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210301033856-bcm_theory/</guid><description>A Hebbian Rule which [see page 3, uses] a non-monotonic transformation function \( \Phi \) and a sliding threshold value (any output below this leads to a negative \( \Delta{w_{ij}} \)) to induce homeostasis. \[ \Delta{w_{ij}} = \alpha \Phi(v_i^{\text{post} - \phi}) v_j^{\text{pre}} \] Where \( \theta = f(\langle v_i^{\text{post}} \rangle) \) varies depending on the average post-synaptic firing rate. If the weights change too much the threshold is increased to minimise (or decrease) the increase in weights, and vice versa.</description></item><item><title>Behavioural State Machine</title><link>https://mohkale.gitlab.io/brain/20210911161526-behavioural_state_machine/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911161526-behavioural_state_machine/</guid><description>Is a state-machine designed to illustrate the reactive [see page 9, behaviour] of anything. It shows how different actions are triggered by events.</description></item><item><title>Bellman Equation</title><link>https://mohkale.gitlab.io/brain/20210628054805-bellman_equation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054805-bellman_equation/</guid><description>A [see page 12, Bellman equation] tells us how an optimal solution for a problem depends on solutions to sub-problems. It's closely related to the idea of optimal substructure.</description></item><item><title>Bernstein Blending Function</title><link>https://mohkale.gitlab.io/brain/20201120214446-bernstein_blending_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120214446-bernstein_blending_function/</guid><description>A [see page 11, function] used to blend between multiple points using a polynomial.
For a BBF defined with 4 polynomials (\(p_1,...,p_4\)) each parameterised by \(u\), the sum of the value of each polynomial at some value \(u\) will always be 1. This restriction makes BBFs useful in bezier curves where a point is guaranteed to not exceed the convex hull of the 4 points defined by a bezier curve.</description></item><item><title>BERT</title><link>https://mohkale.gitlab.io/brain/20201025211607-bert/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025211607-bert/</guid><description>BERT is an [see page 74, extension] of CWR which accounts for the context in which a word is used.
CWR approaches generally attribute the same meaning to the same word, regardless of context. BERT lets us capture the use of words in a context.
BERT was initially used for query re-ranking (assert document relevance using BERT representations). More recent efforts aggregate sentence similarity scores between sentences in a candidate retrieved document and the query.</description></item><item><title>Bezier Curves</title><link>https://mohkale.gitlab.io/brain/20201120213144-bezier_curves/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120213144-bezier_curves/</guid><description>An interpolation algorithm for defining a parametric-curve.
[see page 10, Uses] 4 points 2 keyframes and 2 control points to specify how the curve should vary over time. It defines the curve as a function of these 4 points with a Bernstein Blending Function transformation applied to each of them to produce a smooth curve.
Properties:
The number of control points for a bezier curve is [see page 16, always] one larger than the degree of the curve.</description></item><item><title>Big-O Notation</title><link>https://mohkale.gitlab.io/brain/20210628050932-big_o_notation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628050932-big_o_notation/</guid><description>An asymptotic function which provides a tight [see page 14, upper] bound. A function \( f(n) \) belongs to the set \( \mathcal{O}(g(n)) \) if it can be shown that there's a constant \( c \) such that the function is always smaller than \( g(n) \) for sufficiently large \( n \).
\begin{align*} \mathcal{O}(g(n)) = \{ f(n) : &amp;amp; \text{\; there exists constants \;} 0 &amp;lt; c \text{\; and \;} n_0 \text{\; such that \;} \\</description></item><item><title>Bijection</title><link>https://mohkale.gitlab.io/brain/20210215015653-bijective_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215015653-bijective_function/</guid><description>A function that is both bijective and surjective, I.E. a one-to-one [see page 10, mapping] function. That is to say a function which can map from its domain to the range and from the range back to the domain. Every input maps to a unique output and every output has a unique input.
Note: Every bijection has an inverse, making them invaluable for encoding data.
For a [see page 7, system] with $n$-elements in the domain and $n$-elements in the range we can form up-to \( n!</description></item><item><title>Billboard</title><link>https://mohkale.gitlab.io/brain/20201027215859-billboard/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027215859-billboard/</guid><description>A form of texture mapping where we directly map a 2D texture onto a 3D surface. This can be used to get affects such as [see page 36, trees].</description></item><item><title>Bin Packing</title><link>https://mohkale.gitlab.io/brain/20210622171609-bin_packing_algorithms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622171609-bin_packing_algorithms/</guid><description>Refers to a series of algorithms for problems that can be modelled by packing boxes of different heights into fixed-size bins. In general the problem assumes an infinite number of available bins, with the goal of packing the boxes into as few bins as possible.
We define the lower bound as the lowest theoretical value for a bin packing problem. This is the sum of the values of the boxes divided by the size of the bin.</description></item><item><title>Binary Buddy Allocator</title><link>https://mohkale.gitlab.io/brain/20211003191442-binary_buddy_allocator/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211003191442-binary_buddy_allocator/</guid><description>Is a segregated allocator which maintains its memory as a block of size \(2^n\) (times some base unit number of bytes) that's repeatedly halved until the smallest possible block that satisfies the request is produced. Two freed blocks can be coalesced back together only if they were split from the same parent block (that is if their buddies).
For example if we have one large block of 64KiB and receive a request for 18KiB, we'd first divide into 2 to get two blocks of 64KiB.</description></item><item><title>Binary Function</title><link>https://mohkale.gitlab.io/brain/20210627011221-binary_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627011221-binary_function/</guid><description>A function with arity 2, often written in infix form as \( x f y \). For example \( x + y \).</description></item><item><title>Binary Lexicon</title><link>https://mohkale.gitlab.io/brain/20201117012154-binary_lexicon/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201117012154-binary_lexicon/</guid><description>A lexicon based [see page 13, approach] to sentiment-analysis which associates either a 0/+1/-1 to each word in the lexicon.
Basically:
Select emotions words from input. Assign orientations (+ve, -ve, neutral) to each word. Sum up orientation and assign label to input accordingly. An improvement to this approach can be to Split the sentence using discourse connectives/markers (&amp;quot;it's great but this is bad&amp;quot;). Basically group sections of the sentence into their local polarity.</description></item><item><title>Binary Relation</title><link>https://mohkale.gitlab.io/brain/20210627011919-binary_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627011919-binary_relation/</guid><description>A N-Ary relation with size 2.
Consider the relation \( \leq \) between pairs of numbers.
It's common to express binary relations in infix notation. So the relation \( \leq \) between two numbers \( x \) and \( y \) can be asserted as \( x \leq y \).</description></item><item><title>Binary Search</title><link>https://mohkale.gitlab.io/brain/20210622171338-binary_search/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622171338-binary_search/</guid><description>An algorithm for finding a value in a sorted collection, which at each step cuts the space to be searched in half.
This algorithm works on the assumption that for 3 values in the sorted array \( i, j, k \; i &amp;lt; j &amp;lt; k \), if \( a[i] &amp;lt; a[j] \) then \( a[i] &amp;lt; a[k] \). I.E. transitivity. From this if we're trying to find a value \( x \) in the array and we find that \( a[i] &amp;lt; x \) then we know whatever position in the array where \( x \) can be found must be at a position greater than \( i \) and therefore the subset of the array that's less than \( i \) doesn't need to be checked anymore.</description></item><item><title>Binary Search Tree</title><link>https://mohkale.gitlab.io/brain/20210628054205-binary_search_tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054205-binary_search_tree/</guid><description>Is a data structure wrapping around a binary-tree where every node \( x \) satisfies the binary search-tree property, that is if another node \( y \) is:
In the left sub-tree of \( x \) then \( y.\text{key} \leq x.\text{key} \). In the right sub-tree of \( x \) then \( y.\text{key} \geq x.\text{key} \).
Searching a binary search tree is a \( \mathcal{O}(n) \) time operation, but for a [see page 11, well-balanced] tree the worst-case is \( \mathcal{O}(\log n) = \mathcal{O}(h) \).</description></item><item><title>Binary Tree</title><link>https://mohkale.gitlab.io/brain/20210627061043-binary_tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627061043-binary_tree/</guid><description>A Tree where every node has at most 2 sub-nodes.
Properties of a Binary Search Tree Table 1: Operations on the binary tree data structure. Method Description x.key The value of the node x. x.left A pointer to the root of the left sub-tree of x. x.right A pointer to the root of the right sub-tree of x. The [see page 14, height] of a binary tree is always at most \( \log n \).</description></item><item><title>Bing-Liu Model</title><link>https://mohkale.gitlab.io/brain/20201110205432-bing_liu_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110205432-bing_liu_model/</guid><description>A model for expressing an opinion in some piece of text.
Defines an opinion as a [see page 26, quintuple]:
Term Meaning \(o_j\) Targeted object of the opinion (AKA entity). \(f_{jk}\) A feature of the object \(o_j\). \(so_{ijkl}\) Sentiment value (binary, continuous, discrete etc.). \(h_i\) Sentiment holder. \(t_l\) The time the sentiment was expressed. See [see page 24, example].</description></item><item><title>Binomial Theorem</title><link>https://mohkale.gitlab.io/brain/20210621220106-binomial_theorem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621220106-binomial_theorem/</guid><description>Refers to the expansion of some expression to the power \( n \).
\begin{align} (a+b)^n &amp;amp;= a^n + {n \choose 1} a^{n-1} b + {n \choose 2} a^{n-2} b^2 + \ldots {n \choose k} a^{n-r} b^r + \ldots b^n \\
&amp;amp; \text{where} \\; {n \choose r} = {}^n C\_r = \frac{n!}{r!(n-r)!} \end{align}
\begin{align} (1+x)^n = 1 + nx + \frac{n (n-1)}{1 \times 2} x^2 + \ldots + \frac{n (n-1) \ldots (n-r+1)}{1 \times 2 \times 3} x^r + \ldots, \quad |x| &amp;lt; 1 \forall n \in \mathbb{R} \end{align}</description></item><item><title>Biometrics</title><link>https://mohkale.gitlab.io/brain/20210211182521-biometrics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211182521-biometrics/</guid><description>Fingerprint/Retina-scan/Signature
Warn: Biometrics have many ramifications in the law. Your stolen biometric info can be used to frame you. is a fingerprint a secret protected by law?
Biometric scans are usually more effective when considering the dynamics of how a biometric is produced. For example the final image of a signature is easy to replicate, but the hand motions leading to it are not.</description></item><item><title>BIOS</title><link>https://mohkale.gitlab.io/brain/20210717022616-bios/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717022616-bios/</guid><description>Is firmware (embedded as a special chip in a computers motherboard) which contains instructions for booting it up. The boot chip tells the computer to look in a fixed place, usually the lowest numbered hard disk (the boot disk), for the boot loader which is loaded into memory and started.
The BIOS is often given the very simple job of simply starting the bootloader because its not very advanced. It was originally written for primitive 8-bit PCs with tiny disks and therefore can't access enough of the disk to load the kernel directly.</description></item><item><title>Bipartite Graph</title><link>https://mohkale.gitlab.io/brain/20210622184005-bipartite_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622184005-bipartite_graph/</guid><description>Is a Graph consisting of 2 sets of vertices \( X \) and \( Y \) such that the edges only join vertices from \( X \) to vertices in \( Y \). There aren't any edges connecting vertices in the same set to each other.
\begin{figure} \centering \begin{tikzpicture} \node (l1) [draw, circle] {}; \node (r1) [draw, circle, right=of l1] {}; \node (l2) [draw, circle, below=of l1] {}; \node (r2) [draw, circle, below=of r1, right=of l2] {}; \node (l3) [draw, circle, below=of l2] {}; \node (r3) [draw, circle, below=of r2, right=of l3] {}; \node (l4) [draw, circle, below=of l3] {}; \node (r4) [draw, circle, below=of r3, right=of l4] {}; \node (l5) [draw, circle, below=of l4] {}; \node (r5) [draw, circle, below=of r4, right=of l5] {}; \draw (l1) -- (r1) (l1) -- (r2) (l2) -- (r2) (l2) -- (r3) (l3) -- (r3) (l3) -- (r4) (l3) -- (r5) (l4) -- (r4) (l4) -- (r5) (l5) -- (r5); \end{tikzpicture} \caption{An example of a Bipartite graph with edges only connecting nodes on the left hand side to the right hand side.</description></item><item><title>Biquad Filter</title><link>https://mohkale.gitlab.io/brain/20210131045350-biquad_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131045350-biquad_filter/</guid><description>A \nth{2} order IIR-filter with 5 coefficients. See [see page 7, biquad-filters].
Note: A biquad with 2 poles and 2 zeros are called biquadratics.</description></item><item><title>Bit</title><link>https://mohkale.gitlab.io/brain/20210716042133-bit/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210716042133-bit/</guid><description>Is the smallest distinguishable piece of memory in a computer. It behaves as a boolean being either a 0 or a 1.</description></item><item><title>Bitcoin</title><link>https://mohkale.gitlab.io/brain/20211010030636-bitcoin/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010030636-bitcoin/</guid><description>An application layer protocol for a decentralised crypto-currency.</description></item><item><title>BitTorrent</title><link>https://mohkale.gitlab.io/brain/20211010030712-bittorrent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010030712-bittorrent/</guid><description>An application layer protocol for peer to peer file sharing.</description></item><item><title>Bitwise Agreement</title><link>https://mohkale.gitlab.io/brain/20210215042503-bitwise_agreement/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215042503-bitwise_agreement/</guid><description>Refers to the mathematical state of 2 bits \( A \) and \( B \) where \( A = B \) means \( A \) agrees with \( B \) (otherwise \( A \) disagrees with \( B \)).
Agreement forms the following truth [see page 7, table]:
\(A\) \(B\) \(A \text{Agrees with} B\) 0 0 1 1 0 0 0 1 0 1 1 1</description></item><item><title>Block Cipher</title><link>https://mohkale.gitlab.io/brain/20210215070058-block_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215070058-block_cipher/</guid><description>Is a [see page 3, kind] of Cipher that reversibly maps an entire fixed-length block of bits, using some key, to another fixed-length block of bits. Without knowledge of the key the affect of a block-cipher should look like a random association.
Such ciphers can take advantage of permutation or substitution, unlike stream ciphers, because they can see adjacent bits in the block when deciding how to manipulate them. Stream ciphers only have access to the current plaintext and key bit and thus must perform some operation using those directly.</description></item><item><title>Block Cipher Modes of Use</title><link>https://mohkale.gitlab.io/brain/20210216013003-block_cipher_modes_of_use/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216013003-block_cipher_modes_of_use/</guid><description>Refers to the standard ways of [see page 2, using] a basic block cipher encryption algorithm.</description></item><item><title>Block Device</title><link>https://mohkale.gitlab.io/brain/20211010194134-block_device/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010194134-block_device/</guid><description/></item><item><title>Block Processing</title><link>https://mohkale.gitlab.io/brain/20210130025507-block_processing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130025507-block_processing/</guid><description>Is a form of processing where we take overlapping blocks of a signal at different offsets. Each block can include some samples from the previous block and some from the next block.
overlapping frames, where each frame is partially included in the previous and successive frame. You can calculate the [see page 2, overlap] like so. See [see page 3, here] for some more calculations.
We define:
Term Symbol Meaning Frame Size \(N\) Number of samples per block Frame Shift \(R\) The offset (number of samples) from the end of one block to the start of the next Note: Frame size is often expressed in time eg.</description></item><item><title>Boehm's First Law</title><link>https://mohkale.gitlab.io/brain/20210626212126-boehm_s_first_law/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626212126-boehm_s_first_law/</guid><description> Errors are most frequent during requirements and design activities and are more expensive the later they are removed.
[see page 30, Boehm]</description></item><item><title>Boolean Algebra</title><link>https://mohkale.gitlab.io/brain/20210627005017-boolean_algebra/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627005017-boolean_algebra/</guid><description>Is an algebra [see page 21, defined] using the set \( B = \{ 0, 1 \} \) with 3 operations complementation \( x' \), summation \( x + y \) and product \( x \cdot y \). These operations must satisfy the laws in tbl:bool-laws.
Laws and Rules Table 1: Laws of boolean algebra (see see page 22, [here]). tbl:bool-laws Name LHS RHS Commutativity \( x + y \) \( y + x \) \( x \cdot y \) \( y \cdot x \) Associativity \( (x + y) + z \) \( x + (y + x) \) \( (x \cdot y) \cdot z \) \( x \cdot (y \cdot z) \) Distributivity \( x + (y \cdot z) \) \( (x + y) \cdot (x + z) \) \( x \cdot (y + z) \) \( (x \cdot y) + (x \cdot z) \) Identity \( x + 0 \) \( x \) \( x \cdot 1 \) \( x \) Complement \( x + x' \) 1 \( x \cdot x' \) 0 Table 2: Further laws of boolean algebra derived from tbl:bool-laws (see see page 26, [here]).</description></item><item><title>Boolean Retrieval</title><link>https://mohkale.gitlab.io/brain/20201014222619-boolean_retrieval/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201014222619-boolean_retrieval/</guid><description>An information retrieval model which classifies each document in an index as either relevant or irrelevant to the query. With the basic idea that if a document contains the search term, it's relevant otherwise it isn't.
Supports see page 46, boolean operators but they function as set operations.
This approach is great for producing high precision queries but requires expert knowledge to create them. It's not good for the vast majority of users because:</description></item><item><title>Boot Loader</title><link>https://mohkale.gitlab.io/brain/20210717022846-boot_loader/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717022846-boot_loader/</guid><description>Is a computer program whose job is to start the real OS by looking for and loading a kernel into memory.
One advantage of the boot-loader is that it supports starting one of several OSs from different places on your disk. This allows you to dual-boot or even triple boot different operating systems on a single device.</description></item><item><title>Boot Manager</title><link>https://mohkale.gitlab.io/brain/20210811035046-boot_manager/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811035046-boot_manager/</guid><description>Is a program that can allow multi booting.
I.E. It's a program that discovers and presents operating systems stored in different partitions and allows the user to select one to load at boot.</description></item><item><title>Booting</title><link>https://mohkale.gitlab.io/brain/20210717022532-booting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717022532-booting/</guid><description>Is the process of bringing up the OS.
This process is generally divided into several sub-levels:
Run Level 1: gets the kernel fully loaded. TODO: Rest.</description></item><item><title>Bounding Volumes</title><link>https://mohkale.gitlab.io/brain/20210106004348-bounding_volumes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106004348-bounding_volumes/</guid><description>A ray-tracing intersection [see page 19, optimisation-technique] which wraps complex objects in simpler objects and detects intersection with them before checking all the polygons in the complex object.
Essentially do a quick trial-check before doing a proper full-polygon check. The efficiency of this approach is limited by how well the object can be surrounded by the simpler object.
Examples (with [see page 22, comparisons]) [see page 21, include]:
Spheres AABB (Axis Aligned Bounding Boxes) OBB (Oriented Bounding Box) - Local to objects local coordinate system Combinations We can use combinations of different volumes (eg.</description></item><item><title>Box Plots</title><link>https://mohkale.gitlab.io/brain/20210622165034-box_plots/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622165034-box_plots/</guid><description>Is a figure used to plot the distribution of a set of data, making it easy to compare two or more sets of data. It divides the data into quartiles where each quartile covers a quarter of the distribution of values; that is to say if you sort the distribution and pick the \( \frac{n}{\nth{4}} \) value you get the lower quartile \( Q_1 \). Similarly \( Q_2 \) is the median of the data-set and the upper quartile \( Q_3 \) is the value at the sorted \( \frac{3n}{\nth{4}} \) index of the distribution.</description></item><item><title>Breach of Conduct Remedies</title><link>https://mohkale.gitlab.io/brain/20201018224530-breach_of_conduct_remedies/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018224530-breach_of_conduct_remedies/</guid><description>The actions a party can take in response to a breach of contract.
You can be compensated for [see page 7, a variety] of things, with the most common remedies being the following.
Alternative to these processes, parties can also defer to binding [see page 16, arbitration]. Acknowledge a \nth{3} party arbitrator to look at the facts of the case and make a decision. Arbitration is:
Attribute Why?</description></item><item><title>Breadth First Search</title><link>https://mohkale.gitlab.io/brain/20210628055112-breadth_first_search/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628055112-breadth_first_search/</guid><description>Is an algorithm for [see page 7, traversing] all the nodes of a graph. It works by exploring the frontier between the discovered and undiscovered nodes, essentially placing nodes in a queue as their encountered and then popping them to search them.
def bfs(g, s): for v in g.vertices(): v.color = &amp;#39;white&amp;#39; v.distance = math.Infinity v.search_parent = None q = Queue() s.color = &amp;#39;gray&amp;#39; s.distance = 0 s.search_parent = None q.</description></item><item><title>Break Even Analysis</title><link>https://mohkale.gitlab.io/brain/20210110013949-break_even_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110013949-break_even_analysis/</guid><description>Break even point is the [see page 5, point] at which total revenue equals total cost, I.E. no loss or profit has been made. Break even analysis is the calculation of this point using total costs.
We define
Total revenues as \(Total Costs + Profit = (Fixed Costs + Varaible Costs) + Profits\) Unit Contribution Margin = \(unit Selling Price - Unit Variable Cost\) Contribution Margin Ratio = \(\frac{Unit Contribution Margin}{Unit Selling Price}\) Note: Number of units sold AKA output volume (or just volume).</description></item><item><title>Break Even Chart</title><link>https://mohkale.gitlab.io/brain/20210110014234-break_even_chart/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110014234-break_even_chart/</guid><description>A graph which plots cost and total revenues against sales volume and indicates the break-even-point.
See [see page 12, eg], we plot revenue/cost on the Y-axis and number of units on the X-axis. Fixed costs is drawn as a dashed line parallel to the X-axis. Variable cost is drawn as a straight line through the origin. Total costs is the sum of these two graphs. Sales revenue is the profit per unit.</description></item><item><title>Brickwall Filter</title><link>https://mohkale.gitlab.io/brain/20201121013237-brickwall_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201121013237-brickwall_filter/</guid><description>A filter which has a constant value at some low frequencies and then drops to 0 instantly.</description></item><item><title>Bridge Pattern</title><link>https://mohkale.gitlab.io/brain/20210922043941-bridge_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922043941-bridge_pattern/</guid><description>Is a software design pattern that reduces the number of specialised variants of a concept by encapsulating one varying dimension inside the other.
For example separating the Set, Bag and Stack insertion semantics from the Array, List and Tree elements. This is essentially reducing the duplication in implementations of ArraySet, ListSet, TreeSet, etc.</description></item><item><title>BSD</title><link>https://mohkale.gitlab.io/brain/20211010231110-bsd/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010231110-bsd/</guid><description>Is a free and open-source kernel.</description></item><item><title>Bubble Sort</title><link>https://mohkale.gitlab.io/brain/20210622171707-bubble_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622171707-bubble_sort/</guid><description>Is a sorting algorithm which bubbles values to their correct position in the array. At the end of each iteration at least one new value is guaranteed to be in its correct position in the sorted array.
Formulation n = len(arr) - 1 for i in range(n): swap = 0 for j in range(n - i): if arr[j] &amp;gt; arr[j + 1]: swap(arr, j, j + 1) swap = 1 if swap == 0: break Code Snippet 1: Bubble sort implementation.</description></item><item><title>Buffer Overflow</title><link>https://mohkale.gitlab.io/brain/20211010230956-buffer_overflow/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010230956-buffer_overflow/</guid><description/></item><item><title>Bump Mapping</title><link>https://mohkale.gitlab.io/brain/20201027211120-bump_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027211120-bump_mapping/</guid><description>A texture-mapping alternative which can make an objects surface [see page 24, appear] bumpy.
We store a gray-scale texture ([see page 26, intensity-map]) to indicate where the bumps should appear on the surface. We calculate the vertex normal for the bumps and the actual object and then combine them. This changes the intensity of light on the object producing a bumpy affect.
Note: This approach [see page 28, doesn't alter] the surface, all it does is change the normals causing the visual affect of bumps.</description></item><item><title>Business Finance</title><link>https://mohkale.gitlab.io/brain/20210110052310-business_finance/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110052310-business_finance/</guid><description>The rules and guidelines for financing a business.
Business Structures Many variants but generally fall into [see page 4, 3 categories].
Sole Trader Unincorporated business with just [see page 4, one owner] that pays income tax yearly. This is the simplest and most popular form that's easy to establish and dismantle. Business owner must register the business name with a real (or alias) name. The law sees the business and the owner as the same entity under the law.</description></item><item><title>Byte</title><link>https://mohkale.gitlab.io/brain/20210716042121-byte/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210716042121-byte/</guid><description>Is a unit of digital information consisting of 8-bits.
The size of a byte has in some cases been ambiguous, in which case the term octet represents exactly 8-bits.
Bytes are commonly prefixed with ISO standard values when representing large values. This follows the standard kilo, mega, giga metric prefix as shown in tbl:kilo. An alternative scheme that more closely relates to the binary nature of hard disk drives is the kibi, mibi, gibi prefix standard as shown in tbl:kibi.</description></item><item><title>C</title><link>https://mohkale.gitlab.io/brain/20210930200047-c/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210930200047-c/</guid><description>Is a low level programming language and the standard for serious systems programming due to most kernels exposing their API through C.
Table 1: Complementary programs to assist with C development (some may require building with -g). Program Example gdb An interactive debugger with support for breakpoints and introspection valgrind A suite of tools for debugging and profiling (eg: memory leak detection) ltrace A program to monitor and output any system/library calls in a program strace Like ltrace but can also modify the program to assist in debugging Language Pre-processor The pre-processor is a program that processes c-code before the compiler and linker can get to it.</description></item><item><title>Caesar Cipher</title><link>https://mohkale.gitlab.io/brain/20210215021449-caesar_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215021449-caesar_cipher/</guid><description>A Substitution Cipher which [see page 10, permutes] the letters of the alphabet \( A \) forwards by some offset. For example A permutes to B in a ceaser-cipher with an offset of 1.
Decryption for a Caesar cipher is simply offseting the ciphertext character by the negative offset so B decrypts to A with an offset of 1 for the encryption.</description></item><item><title>Camera</title><link>https://mohkale.gitlab.io/brain/20201017155231-camera/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201017155231-camera/</guid><description>A [see page 6, camera] gives us a viewpoint into our scene.
It can be:
Positioned anywhere in the world coordinate system. Point anywhere. Rotate about the viewing direction. The cameras see page 4, view space is parameterised by:
Term Meaning Viewpoint Where the camera is positioned. Viewing Direction Where the camera is facing. View-Volume The area of the world that can be seen.</description></item><item><title>CAP</title><link>https://mohkale.gitlab.io/brain/20201127015730-cap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127015730-cap/</guid><description>Term Meaning Consistency Every read receives the most recent write or a timeout error. Availability Every request receives a response which may be stale. Partition Tolerance The system continues to operate despite arbitrary partitions. Note: By stale I mean there's no guarantee that the response contains the most recent version of the information
Note: A partition is blockage due to network failures.</description></item><item><title>CAPEC</title><link>https://mohkale.gitlab.io/brain/20210430005911-capec/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430005911-capec/</guid><description>A [see page 62, standard] for identifying threats which simply selects a subset of standard possible threats that could apply to your application.</description></item><item><title>Capital Investment Appraisal</title><link>https://mohkale.gitlab.io/brain/20210110030318-capital_investment_appraisal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110030318-capital_investment_appraisal/</guid><description>Appraising the viability and practicality of an Investment opportunity.
When deciding on an investment a firm must consider: risk &amp;amp; uncertainty, monetary returns and non-monetary business objectives.
Opportunity cost of an investment is the minimum expected return (or yield) of the investment.
Appraisal Techniques Accounting rate of return Is the [see page 9, ratio] of \(\frac{Average Expected Return}{Averge Captial Employed/Investment}\). The AER is the total cash flow over the investment period divided by the investment duration (we don't consider the initial investment or scrap returns).</description></item><item><title>Capital Rationing</title><link>https://mohkale.gitlab.io/brain/20210110030651-capital_rationing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110030651-capital_rationing/</guid><description>Is capital-investment-appraisal related to comapring and contrasting multiple projects competing for available funds.</description></item><item><title>Cardinal Vowel</title><link>https://mohkale.gitlab.io/brain/20201020211030-cardinal_vowel/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020211030-cardinal_vowel/</guid><description>A set of language independent vowels. These appear scattered [see page 16, around] the edges of the vowel quadrilateral.
They are defined as:
The highest quality of sound that can be produced without causing turbulence. Try saying eeeee out loud and notice how the sound is completely dependent on how your vocal system is shaped.</description></item><item><title>Cartesian Product</title><link>https://mohkale.gitlab.io/brain/20210627005610-cartesian_product/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627005610-cartesian_product/</guid><description>For two sets \( A \) and \( B \), their cartesian product is the set of all ordered pairs \( (a, b) \) where \( a \in A \) and \( b \in B \). \[ A \times B = \{ (a, b) : a \in A \land b \in B \} \]
Inversion We define an [see page 9, inversion] of a Cartesian product as the reversal of the order of the tuples of the product.</description></item><item><title>Cepstral Analysis</title><link>https://mohkale.gitlab.io/brain/20210108012952-cepstral_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210108012952-cepstral_analysis/</guid><description>Is a see page 1, method to separate the vocal tract filter response from the excitation.
This takes advantage of the fact that the spectrum of a speech signal is the product of the excitation spectrum and the vocal-tract frequency response.
Recall that: \[ \log(a . b) = log(a) + log(b) \] From this and the above observation we know that the log-spectrum of a signal is the summation of the log of the excitation spectrum and the log of the vocal-tract frequency response.</description></item><item><title>Certainty</title><link>https://mohkale.gitlab.io/brain/20201018223528-certainty/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018223528-certainty/</guid><description>The more certain the facts/laws the lower the likelihood of dispute. Although if performance of the contract has already begun then the courts are likely to consider it valid.</description></item><item><title>Certifying Authority</title><link>https://mohkale.gitlab.io/brain/20210429004715-certifying_authority/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429004715-certifying_authority/</guid><description>Is an entity who authenticates organisations by signing their public keys.
Browsers generally have a list of trusted *CA*s and any organisations they trust is transitively trusted by the browser.</description></item><item><title>CGI</title><link>https://mohkale.gitlab.io/brain/20210908013645-cgi/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210908013645-cgi/</guid><description>Is an early method for creating interactive web pages which passes HTML requests from a server to a CGI script (or program), one process for each request, whose output is then redirected back to the sender.</description></item><item><title>Chain Loading</title><link>https://mohkale.gitlab.io/brain/20210811034748-chain_loading/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811034748-chain_loading/</guid><description>Is the process of invoking VBR through a boot manager.</description></item><item><title>Chain of Custody</title><link>https://mohkale.gitlab.io/brain/20210306154255-chain_of_custody/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210306154255-chain_of_custody/</guid><description>The concept of maintaining a [see page 2, record] of of everything that has happened to a confiscated item between its collection and its appearance in court (preferably unaltered)
The goal is to preserve the integrity of the evidence and prevent it from contamination.
See [see page 4, example] of a chain-of-custody form.
Accountability We must account for:
Concern Description Collection Where was it collected from?</description></item><item><title>Chain of Responsibility</title><link>https://mohkale.gitlab.io/brain/20210922044440-chain_of_responsibility/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922044440-chain_of_responsibility/</guid><description>Is a software design pattern where more than one object is give the opportunity to handle a request, passing it along a chain of receiving objects.</description></item><item><title>Channel</title><link>https://mohkale.gitlab.io/brain/20210211235317-channel/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211235317-channel/</guid><description>A means for inter-subject communication. I.E. A way for one subject to communicate/signal something to another subject.
An example of a channel is a file.</description></item><item><title>Characters &amp; Glyphs</title><link>https://mohkale.gitlab.io/brain/20201004164106-characters_and_glyphs/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201004164106-characters_and_glyphs/</guid><description>A Characters is the smallest component of a writing system that has a semantic value. Often reffered to as a grapheme (however a grapheme may also reference multiple characters as a single character, eg. à).
A phoneme is the smallest sound unit in a spoken language.
A glyph is the reorientation of (one or more) character(s) as they are rendered/displayed.
When deciding on the set of characters for a language for purposes of representing them in a computer, it is extremely important (e.</description></item><item><title>Cieling</title><link>https://mohkale.gitlab.io/brain/20210627060008-cieling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627060008-cieling/</guid><description>Is an algorithm to round a non-integer rational number to the subsequent integer. Mathematically we represent rounding a number \( i \) as \( \lciel i \rciel \).</description></item><item><title>Cipher</title><link>https://mohkale.gitlab.io/brain/20210215021132-cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215021132-cipher/</guid><description>An algorithm for performing encryption or decryption in a cryptographic system using a series of well-defined steps.</description></item><item><title>Cipher Block Chaining</title><link>https://mohkale.gitlab.io/brain/20210216013321-cipher_block_chaining/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216013321-cipher_block_chaining/</guid><description>A mode of use for block-ciphers which masks occurrence of identical plain-text blocks in messages by using the encrypted output of the previous block to calculate the output of the current block.
Encryption and Decryption [see page 16, Method]:
Produce an initial block. XOR the first input-block with the initial-block then encrypt the output (for example using ECB) to produce the ciphertext \( C_1 \). Replace the initial-block with \( C_1 \) and go-to step 1 with subsequent plaintext blocks.</description></item><item><title>Cipher Feedback Mode</title><link>https://mohkale.gitlab.io/brain/20210216013618-cipher_feedback_mode/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216013618-cipher_feedback_mode/</guid><description>A modes of use for cipher-blocks which lets you encrypt data a bit at a time.
This is crucially useful for transmission across networks or a terminal.
Encryption and Decryption [see page 32, Method]:
Generate an input-block. Encrypt the input-block (for example using ECB). XOR the plaintext bit with the left-most bit of the encrypted input-block to get the first ciphertext bit. Left shift the input-block (prior to encrypting it), truncating the left most bit, and set the right-most bit to match the output of step 3.</description></item><item><title>Circle</title><link>https://mohkale.gitlab.io/brain/20210621202138-circle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621202138-circle/</guid><description>A geometric shape with the property that every point on the shape is equidistant to its center.
Area on the surface of a face is \[ A = \pi r^2 \]
Circumference (length along the rim) is \[ 2 \pi r \]
The general equation of a circle with radius \( r \) and centre \( (a,b) \) is
\begin{align} (x - a)^2 + (y - b)^2 = r^2 \label{eq:circ-general} \end{align}</description></item><item><title>Civil Law</title><link>https://mohkale.gitlab.io/brain/20201001232503-civil_law/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201001232503-civil_law/</guid><description> Legal action is brougt by the individual who feels they have suffered. Action is brough against infringing party Any sum of damages identified as payable by the court goes to the claimant Claimant must show that defendent probable to have commited the offence</description></item><item><title>Class Diagram</title><link>https://mohkale.gitlab.io/brain/20210701011807-class_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701011807-class_diagram/</guid><description>Is a UML data-view diagram outlining the classes and inheritance model of a system. It relates strongly to the ERM except wheras ERM describes the abstract representation of the data model, the class diagram represents the static structure and behaviour of the proposed system.
Class diagrams are more likely to map to real world objects.
Class Overview A class can be seen as a set containing all possible instances of a given type.</description></item><item><title>Classification</title><link>https://mohkale.gitlab.io/brain/20210211230450-classification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211230450-classification/</guid><description>We define [see page 10, classification] as constructing a hierarchy of classes of security levels. eg. Top secret must be more closely protected than restricted or unclassified.
The classes we commonly use in order from highest-to-lowest sensitivity are:
1. Top_Secret 2. Secret 3. Confidential 4. Restricted 5. Unclassified Note: Security classes often form a [see page 43, lattice].
Mathematical Properties The relationships between classes is defined as see page 11, dominant, and has the following properties:</description></item><item><title>Click Thru</title><link>https://mohkale.gitlab.io/brain/20201025205020-click_thru/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025205020-click_thru/</guid><description>The pages viewed by a user through a search engine. I clicked through to this page from your engines search results.
Click Thru can be repurposed in relevance feedback and for teaching your engine to learn how to rerank search results (See. learn-to-rank algorithms).</description></item><item><title>Clickjacking</title><link>https://mohkale.gitlab.io/brain/20210630232541-clickjacking/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630232541-clickjacking/</guid><description>Is a security vulnerability where we redirect web access, such as to a fake login page, and sniff passwords or other sensitive data in transit.</description></item><item><title>Clone</title><link>https://mohkale.gitlab.io/brain/20211003212737-clone/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211003212737-clone/</guid><description>Is a system-call that creates a new child-process similar to fork, but for threads. See clone.
Note: You'll rarely be calling this low level function directly, since it requires a manual definition of the stack pointer and other details. Instead you can use the pthread library to define them (See pthread-functions).</description></item><item><title>Clustering</title><link>https://mohkale.gitlab.io/brain/20210301041434-clustering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210301041434-clustering/</guid><description>A form of unsupervised learning where we identify and group similar samples based on the structure of the data.
While clustering can be useful for grouping it isn't very useful for classification, unless you have some way of associating the clusters with samples.
A complete clustering forms a [see page 7, voronoi tesselation], where the boundary between two clusters can be seen as the decision boundary between one class of clusters and another.</description></item><item><title>CMake</title><link>https://mohkale.gitlab.io/brain/20220111091350-cmake/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220111091350-cmake/</guid><description>Is a cross-platform build tool for the C language with it's own domain-specific configuration language.
CMake is configured using a CMakeLists.txt file (also referred to as CML files). This file is written in the CMake build language. You can hierarchically construct build configurations be placing CML files in different directories depending on how you layer out your project.
# Declare CMake version to use and project name cmake_minimum_required(VERSION 3.12)project(program LANGUAGES C CXX) # Languages is optional # Include CMakeLists.</description></item><item><title>Co-Domain</title><link>https://mohkale.gitlab.io/brain/20210626025240-co_domain/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626025240-co_domain/</guid><description>The set of values that could possibly be outputted by a function. This differs from the range in that the range is a subset of the co-domain but the two aren't necessarily equivalent.</description></item><item><title>Coarticulation</title><link>https://mohkale.gitlab.io/brain/20201020224029-coarticulation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020224029-coarticulation/</guid><description>How one sound [see page 20, influences] another sound. This can be seen as a form of context dependency (by engineers) or as a consequence of efficient motor planning.
Essentially sounds seem to overlap or inter-depend which finding clear boundaries to separate them increasingly difficult.
See why are you early you owl?</description></item><item><title>Cochlea</title><link>https://mohkale.gitlab.io/brain/20210129012308-cochlea/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129012308-cochlea/</guid><description>[see page 6, Converts] sound waves into electrical signals for the brain to process. Essentially a very advanced form of frequency-analysis.
The cochlea is 35mm long and covered in a colourless liquid called perilymph and another liquid called endolymph. It consists of two membranes:
Basilar membrane Reissner's membrane It's divided into 2 regions along its length by the cochlea partition.
There're [see page 6, hairs] all around the cochlea.</description></item><item><title>Code Metrics</title><link>https://mohkale.gitlab.io/brain/20210626234925-code_metrics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234925-code_metrics/</guid><description>A class of metrics which use measurements of the actual [see page 36, code] base.</description></item><item><title>Code Segment</title><link>https://mohkale.gitlab.io/brain/20210717194126-code_segment/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717194126-code_segment/</guid><description>Is the read-only area of a processes memory space where the process instructions are stored.
In Unix when two of the same processes are being run concurrently, it's arranged that they both reference the same code-segment.</description></item><item><title>Code Synchronisation</title><link>https://mohkale.gitlab.io/brain/20201102012023-code_synchronisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102012023-code_synchronisation/</guid><description>A [see page 13, technique] for achieving random acess in compressed files.
Sync Points Assume there's some smallest unit of random access in a compressed archive (eg. a document) and find a way to make random access for that unit. This can be done by:
Storing bit offset of document in archive. Ensuring the document ends on a byte boundary. Note: This approach is only viable in a limited domain and only for documents you know you'll be wanting to access after compression.</description></item><item><title>Codebook</title><link>https://mohkale.gitlab.io/brain/20210215020922-codebook/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215020922-codebook/</guid><description>A book of codes, I.E. a list of strings/keywords which can be substituted for other words to encrypt a message.
Essentially a mapping from plain-text blocks to cipher-text blocks.
Note: Codebooks are symmetric, you can swap the inputs and outputs (encryption and decryption) but if you apply both in any order in the same input you get the initial input back out \(\text{ENC}(\text{DEC}(X)) = \text{DEC}(\text{ENC}(X)) = X\).
Vulnerabilities We can use code-books to forge a message pretending to be a legitimate communicant.</description></item><item><title>Coding Theory</title><link>https://mohkale.gitlab.io/brain/20201102174112-coding_theory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102174112-coding_theory/</guid><description>Find how much see page 9, information is in a signal.
Information that's relevent to coding theory is:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } **Entropy** Information in a random variable (amount of information in a signal). \\[ H(x) = - \sum\_{x \in X} p(x){\log p(x)} \\] **Mutual Information** Amount of information that's common in two random variables. \\[ I(X;Y) = \sum\_{x, y} p(x, y){\log \frac{p(x,y)}{p(x) \times p(y)}} \\] Entropy indicates ease of compression (due to redundancy).</description></item><item><title>Coffman Conditions</title><link>https://mohkale.gitlab.io/brain/20211008011718-coffman_conditions/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008011718-coffman_conditions/</guid><description>Are 4 necessary and sufficient conditions for a deadlock:
Mutual Exclusion: No 2 processes can obtain a resource at the same time.
If this isn't the case then no process is waiting on another process for a resource since two can acquire it at the same time, thus there's no circular wait and no deadlock.
Circular Wait: There exists a cycle in the RAG.
Without a circular wait we know there is no cycle in the RAG, meaning there's at least one process that isn't waiting on a resource to be freed.</description></item><item><title>Cognitive Science</title><link>https://mohkale.gitlab.io/brain/20210926211036-cognitive_science/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926211036-cognitive_science/</guid><description>Is a disciplinary field that brings together computer models from AI and experimental techniques from psychology to construct precise testable theories of the human mind.
By design cognitive science is based on experimental investigation.
Behaving Humanly There are 3 ways of [see page 23, assessing] something behaves humanly.
Introspection: Trying to catch our own thoughts as they go by. Observation: Of a persons behaviour in action. Brain Imaging: Analysing the exact fluctuation of brain waves.</description></item><item><title>Cohesion</title><link>https://mohkale.gitlab.io/brain/20210626234726-cohesion/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234726-cohesion/</guid><description>A design metric that [see page 29, measures] how well a component fits together, that is whether everything in a bundle of code (referred to as a component) needs to be there.
In general a component should be highly cohesive, implementing a single logical entity or function, and changes (when required) should be localised to a single cohesive component. Components can be classes, modules or higher level groupings of code.</description></item><item><title>Collection Period</title><link>https://mohkale.gitlab.io/brain/20201021174211-collection_period/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021174211-collection_period/</guid><description>How soon after a purchase a company recieves money from its customers.
\[ \frac{Trade Receivable}{Revenue} \]
In general this period [see page 27, should] be neither too long nor too short.</description></item><item><title>Color Mapping</title><link>https://mohkale.gitlab.io/brain/20201027211717-color_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027211717-color_mapping/</guid><description>Is a form of texture mapping.
The most common approach to color-mapping is inverse-mapping:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } For a pixel in screen space (on the objects surface) find its pre-image (the pixel it maps to) in texture space. Entire [see page 11, [areas](COM3503-w05-textures-01)] in screen space can map to a single pixel in a texture. This works by [see page 12, dividing] the texture into a 2D area with \((0,0)\) at the bottom-left and \((1,1)\) at the top-right.</description></item><item><title>Command Pattern</title><link>https://mohkale.gitlab.io/brain/20210922051719-command_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922051719-command_pattern/</guid><description>Is a software design pattern where a function is encapsulated as an object with a single execute method (for example Java Actions objects).
This pattern uses an extensible top level interface [see page 24, indicating] generic behaviour.</description></item><item><title>Commercial Constraints</title><link>https://mohkale.gitlab.io/brain/20210906004435-commercial_constraints/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906004435-commercial_constraints/</guid><description>Constraints relating to particular prior commitments or restrictions on what can be used and why.
Constraint Relating To Greenfield vs. Brownfield From scratch or in addition to an existing system Vendor lock-in Particular hardware or software suppliers In-house support Existing technology (example: web, db, language)</description></item><item><title>Common Cost Model</title><link>https://mohkale.gitlab.io/brain/20210628050436-common_cost_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628050436-common_cost_model/</guid><description>A way to measure the runtime of an algorithm by [see page 9, counting] the number of elementary operations on a RAM model.
See an [see page 16, example] with insertion-sort.</description></item><item><title>Comparison Sorts</title><link>https://mohkale.gitlab.io/brain/20210628053344-comparison_sorts/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053344-comparison_sorts/</guid><description>A sorting algorithm that relies on [see page 3, comparing] elements with each other.
Note: an algorithm that performs few comparisons could be preferable to ones making many comparisons (such as quick sort) depending on the needs of the problem. Comparisons can be [see page 20, costly], especially if the keys to be compared are not numbers but more complex objects (Strings, Arrays, etc.)
Lower Bound for Comparison Sorts There is also a lower-bound for the running time of all sorting algorithms that rely on comparisons only.</description></item><item><title>Competitive Neural Network</title><link>https://mohkale.gitlab.io/brain/20210301043112-competitive_neural_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210301043112-competitive_neural_network/</guid><description>A unsupervised clustering implementation based around neural networks using the BCM update rule.
Formulation Assign \( x^{\mu} \longrightarrow w_k \) where \( w_k^T x^{\mu} \geq w_i^T x^{\mu} \forall i \). That is to say assign input sample \( x^{\mu} \) to the closest cluster centroid \( k \), which is equivalent to the cluster associated with the winning neuron \( k \). Update the weights of only the winning neuron \( k \) by: \( \Delta{w_k} = \alpha (x^{\mu} - w_k) \).</description></item><item><title>Compiled Language</title><link>https://mohkale.gitlab.io/brain/20210718023301-compiled_language/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718023301-compiled_language/</guid><description>Is a programming language that is translated into runnable files of binary code through a program known as a compiler. Compiled binaries can be run without the original source code being required.</description></item><item><title>Complete Graph</title><link>https://mohkale.gitlab.io/brain/20210622174804-complete_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174804-complete_graph/</guid><description>A graph in which each of the \( n \) vertices is connected to every other vertex.</description></item><item><title>Complete Matching</title><link>https://mohkale.gitlab.io/brain/20210622190410-complete_matching/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622190410-complete_matching/</guid><description>Is a matching where every node in the graph is incident to exactly one edge in the matching.
\begin{figure} \centering \begin{tikzpicture} \node (l1) [draw, circle] {}; \node (r1) [draw, circle, right=of l1] {}; \node (l2) [draw, circle, below=of l1] {}; \node (r2) [draw, circle, below=of r1, right=of l2] {}; \node (l3) [draw, circle, below=of l2] {}; \node (r3) [draw, circle, below=of r2, right=of l3] {}; \node (l4) [draw, circle, below=of l3] {}; \node (r4) [draw, circle, below=of r3, right=of l4] {}; \node (l5) [draw, circle, below=of l4] {}; \node (r5) [draw, circle, below=of r4, right=of l5] {}; \draw [color=red] (l1) -- (r1) (l2) -- (r2) (l3) -- (r3) (l4) -- (r4) (l5) -- (r5); \draw [color=black!</description></item><item><title>Completing the Square</title><link>https://mohkale.gitlab.io/brain/20210621204751-completing_the_square/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621204751-completing_the_square/</guid><description>Is a special reformulation of a quadratic equation into the form \[ a(x+d)^2 + e \] This form has some special properties that makes it preferable to the expanded form in some situations.
Properties include:
\( (-d, e) \) is the minimum (or maximum) point of the line formed by \( y \). \( \begin{pmatrix}-ad \\ e\end{pmatrix} \) is the vector of translation from the line \( y=x^2 \). The line of symmetry of \( y \) is \( x = -d \).</description></item><item><title>Complex Numbers</title><link>https://mohkale.gitlab.io/brain/20210130061817-complex_numbers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130061817-complex_numbers/</guid><description>Are a class of numbers with both real and imaginary parts. (eg. \(z = x + ji\)).
The Cartesian form of all complex numbers is: \[ z = a + bi \] where \( Re(z) = a \) is the real part, \( Im(z) = b \) is the imaginary part and \( i \) is the imaginary constant.
Arithmetic Operations For two complex numbers \( z_1 = 2 + i \) and \( z_2 = 3 - 2i \).</description></item><item><title>Component</title><link>https://mohkale.gitlab.io/brain/20210629021340-component/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210629021340-component/</guid><description>A small, independent, component of a larger software system.
A collection of components can be thought of as a component architecture (or framework).</description></item><item><title>Component Based Development</title><link>https://mohkale.gitlab.io/brain/20210629020739-component_based_development/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210629020739-component_based_development/</guid><description>Is a software development model where we create and composes small, loosely coupled software components into a larger software system. CBD aims to emphasise the separation of concerns with respect to the wide ranging functionality available throughout an entire system. For example you could have an payment component that's accessed by both a purchase and sale component.
Generally [see page 18, divided] into 3 phases:
Development: Collect system requirements as a set of top-down tasks and analyse how they map onto software components.</description></item><item><title>Composite Cipher</title><link>https://mohkale.gitlab.io/brain/20210215031320-composite_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215031320-composite_cipher/</guid><description>Are ciphers which [see page 16, combine] both permutation and substitution to produce more secure ciphers. Many modern ciphers are implemented using multiple layers of this same system.</description></item><item><title>Composite Number</title><link>https://mohkale.gitlab.io/brain/20210831003756-composite_number/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210831003756-composite_number/</guid><description>A number that cannot be broken down into factors of one or more numbers greater than 1. For example \( 8 \) can be broken down into \( 4 \times 2 \) or \( 2 \times 2 \times 2 \times 2 \).</description></item><item><title>Composite Pattern</title><link>https://mohkale.gitlab.io/brain/20210911175954-composite_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911175954-composite_pattern/</guid><description>Is a software design pattern where a group of objects can be interacted with like a single instance of the object. This is done by having the instance store a collection of instances deriving from its parent class and then calling the same action on all of those objects when that action is called on it.
This pattern coordinates objects with similar interfaces [see page 24, indicating] loose coupling.
\begin{figure} \centering \begin{tikzpicture} \umlsimpleclass{Client} \umlclass[x=3cm]{Component}{}{action1() \\ action2()} \umlclass[x=7cm, y=1.</description></item><item><title>Composition</title><link>https://mohkale.gitlab.io/brain/20210911020816-composition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911020816-composition/</guid><description>Is a relationship between 2 entities expressing a [see page 23, whole-parts] relationship where the parts depend on the owning whole. If the whole is broken down the parts cease to exist.
\begin{figure} \centering \begin{tikzpicture} \umlclass{Order}{ orderNumber: Integer \\ date: Date}{}; \umlclass[y=-5]{OrderLine}{ productCode: Integer \\ quantity: Integer \\ price: Real}{}; \umlaggreg[attr2=lines|1..*]{Order}{OrderLine}; \end{tikzpicture} \caption{Example of a composition relationship. Individual order-lines cannot exist without the owning order.} \end{figure}</description></item><item><title>Compound Key</title><link>https://mohkale.gitlab.io/brain/20210815020739-compound_key/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815020739-compound_key/</guid><description>Refers to relational database table that uses multiple primary key or foreign key to uniquely, in combination, identify a record.</description></item><item><title>Compression Entropy</title><link>https://mohkale.gitlab.io/brain/20201029170359-compression_entropy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201029170359-compression_entropy/</guid><description>We define \(I(s)\) as the number of bits which symbol \(s\) should be coded in. I.E. The information content of \(s\). This metric is directly related to the predicted probability of that symbol and can be defined as: \(I(s) = -log_{2}(P[s])\) where \(P[s] = the probability of symbol s\).
We [see page 54, define] the entropy, \(H\), of a probability distribution as the average information per symbol over the whole alphabet.</description></item><item><title>Compression Model</title><link>https://mohkale.gitlab.io/brain/20201104000134-compression_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201104000134-compression_model/</guid><description>A representation model/dictionary of some textual data that can be used to improve storage.
Most compression algorithms need a model before they can begin encoding. Decoding is impossible without the relevant model.
Models can be [see page 72, built] in various ways depending on the algorithm.
We can classify a model based on how it uses the surrounding [see page 70, context]:
finite context zero order Word based models consist of words ([A-z0-9] strings) and non-words (space/punctuation).</description></item><item><title>Compression Random Access</title><link>https://mohkale.gitlab.io/brain/20201102011201-compression_random_access/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102011201-compression_random_access/</guid><description>The ability to access sections of a compressed file directly. You can read part of a compressed file without first having to decompress all of it.
Good compression techniques [see page 12, make] random access difficult, because:
variable length encoding can't start decoding at a random point. They have to be on a code boundary. adaptive models cannot determine the model without decoding all prior text first. Note: There's no good random access solution for adaptive modelling.</description></item><item><title>Computer</title><link>https://mohkale.gitlab.io/brain/20210717014839-computer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717014839-computer/</guid><description>A machine that can be programmed to carry out a sequence of arithmetic or logical operations automatically.</description></item><item><title>Computer Bus</title><link>https://mohkale.gitlab.io/brain/20210717015341-computer_bus/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717015341-computer_bus/</guid><description>A bus is a physical connection between the various components of a computer. It's the data-highway between your processor, your screen, your disk and everything else.
Almost all communication between hardware takes place through buses.</description></item><item><title>Computer Graphics</title><link>https://mohkale.gitlab.io/brain/20200929001256-computer_graphics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200929001256-computer_graphics/</guid><description>At a high level, computer graphics [see page 8, differs] from
Computer Vision - understanding what is being seen, classifying objects. Image Processing - identify characteristics or ways to better present important features of an image. Computer Graphics is more taking a description of a scene and producing an image for it.
Uses:
Training and Testing Designing Understanding through scientific visualisation Enhancing the existing world (augmented reality) Entertainment/Pleasure Real In CG we have to do:</description></item><item><title>Computer Network</title><link>https://mohkale.gitlab.io/brain/20210719190846-computer_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719190846-computer_network/</guid><description>Is a collection of computers that're linked together and can communicate between each other.</description></item><item><title>Computer Security &amp; Forensics</title><link>https://mohkale.gitlab.io/brain/20210211053352-computer_security_forensics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211053352-computer_security_forensics/</guid><description>Relates to the hardening and analysis of the ways to perform, analyse and prevent security attack.
Hackers Are Like Artists, Who Wake Up In A Good Mood &amp;amp; Start Painting
Vladimir Putin See [see page 3, leak examples], kinds of information compromised, and see page 5, costs.
The top 3 [see page 15, fundamental concepts] of security are confidentiality, integrity and availability.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Once you've compromised one account, you can pretty easily compromise many others.</description></item><item><title>Computer Virus</title><link>https://mohkale.gitlab.io/brain/20210630234312-computer_virus/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630234312-computer_virus/</guid><description>Malware that attaches itself to other programs to harm the computer system.</description></item><item><title>Computer Worm</title><link>https://mohkale.gitlab.io/brain/20210630232708-computer_worm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630232708-computer_worm/</guid><description>Is malware that reproduces itself ad-nauseum to slow down computer systems.</description></item><item><title>Condition Variables</title><link>https://mohkale.gitlab.io/brain/20211007001810-condition_variables/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211007001810-condition_variables/</guid><description>Is a construct that allows a set of threads to sleep until woken up. Condition variables are used in situations where one thread has to block until some condition is met (example a stack is full so you can't push onto it) but that condition has to be achieved by another thread that must communicate the change back to it.
// Thread 1 while (1) { lock(mutex); // Blocks waiting for notification from Thread 2.</description></item><item><title>Confidentiality</title><link>https://mohkale.gitlab.io/brain/20210211054052-confidentiality/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211054052-confidentiality/</guid><description>Protecting information from disclosure to unauthorised parties.</description></item><item><title>Confusion Matrix</title><link>https://mohkale.gitlab.io/brain/20201203200214-confusion_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201203200214-confusion_matrix/</guid><description>Is a way to visually represent the accuracy of a classifier based on sampled training data.
Along the horizontal axis we place the actual class of each sample, along the vertical axis we place what our classifier output for that sample.
For example:
CAT DOG CAT | 5 | 2 | DOG | 3 | 3 | From our definition above and this example we can tell that the classifier was given 8 pictures of cats and 5 of dogs.</description></item><item><title>Connected Graph</title><link>https://mohkale.gitlab.io/brain/20210622174321-connected_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174321-connected_graph/</guid><description>Two vertices are said to be connected if there is a path between them. A graph is connected if all its vertices are connected.</description></item><item><title>Consideration</title><link>https://mohkale.gitlab.io/brain/20201018223208-consideration/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018223208-consideration/</guid><description>&amp;#34;The price one pays for another promise.&amp;#34; - Pollock &amp;#34;A valuable consideration, in the sense of the law, may consist either in some right, interest, profit or benefit accruing to the one party, or some forbearance, detriment, loss or responsibility, given, suffered, or undertaken by the other&amp;#34; Currie v Misa (1875) Basically what one party intends to do for the other in exchange for the promise of some service or object.</description></item><item><title>Consistency</title><link>https://mohkale.gitlab.io/brain/20201127022127-consistency/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127022127-consistency/</guid><description>Refers to the consistency part of CAP.
Weak Consistency .org-center { margin-left: auto; margin-right: auto; text-align: center; } After a write, reads may or may not see it. A best effort approach is taken. Works well in real time cases such as video-chat, real-time multiplayer-games. For example if you lose connection in the middle of a phone call you don't hear the lost speech after a connection is re-established.</description></item><item><title>Consistent Hashing</title><link>https://mohkale.gitlab.io/brain/20201127025241-consistent_hashing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127025241-consistent_hashing/</guid><description>A kind of hashing function designed to minimise the consequences of rehashing. That is to say when the number of hash targets changes (such as when we receive more buckets or servers to hash to) consistent hashing avoids changing the hash output of every input.
TODO elaborate on consistent-hashing algorithm</description></item><item><title>Consonant</title><link>https://mohkale.gitlab.io/brain/20201020203233-consonant/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020203233-consonant/</guid><description>Sound segments which cause our airflow to be partly (or fully) obstructed. In english the consonants are ZBTGH.
Consonants are NOT vowels.</description></item><item><title>Constraint</title><link>https://mohkale.gitlab.io/brain/20210911023203-constraint/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911023203-constraint/</guid><description>Are properties that can be attached to any UML construct. It's drawn as a label enclosed in { curly-brackets }.
Overlapping Disjoint</description></item><item><title>Constructive Solid Geometry</title><link>https://mohkale.gitlab.io/brain/20201016221944-constructive_solid_geometry/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201016221944-constructive_solid_geometry/</guid><description>A 3D representation based on the combination or exclusion of multiple [see page 17, geometric primitives] to create objects. This representation is stored as an object model tree with leaves being primitives and nodes working as linear transformations or boolean operators (combine these two shapes, exclude the right hand shape from the left one).
Advantages:
Compact Modelling history is recorded (simply shape editing is easy) Easy to validate representations Disadvantages:</description></item><item><title>Containers</title><link>https://mohkale.gitlab.io/brain/20220201142829-containers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201142829-containers/</guid><description>Are effectively lightweight virtual machines that can be initialised from a container image. Containers remove the overhead of unnecessary system components such as hardware emulation and instead expose the bare minimum of the underlying OS to get a working containerised system.
Containers offer:
Resource isolation: the memory, file-system and network stack or all isolated from the rest of the system. Effortless parallelisation: you can spin up multiple containers on a single machine and dedicate them to running a specific process or service.</description></item><item><title>Continuants</title><link>https://mohkale.gitlab.io/brain/20201020213424-continuants/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020213424-continuants/</guid><description>Speech sounds that can be [see page 2, sustained] over time and retain their phonetic quality (basically for as long as you can keep your breath going). This extends to:
All fricatives Some approximants All nasals Monopthong vowels By retaining phonetic quality, the spectogram entry for such words retain the same shape over time.
When [see page 7, visualised] on a spectogram, these show up as a continuous sequence.</description></item><item><title>Continuous Bag of Words</title><link>https://mohkale.gitlab.io/brain/20201025205959-cbow/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025205959-cbow/</guid><description>An approach in CWR.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Train shallow feed forward neural network to predict missing target word w in middle of 2k+1 words. For example, to build a vector for the word aardvark.
Find many documents with the word aardvark. Replace aardvark with one of k-words before and after aardvark. Train the network to detect the queried word was aardvark from the documents I.</description></item><item><title>Continuous Integration</title><link>https://mohkale.gitlab.io/brain/20210626232331-continuous_integration/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626232331-continuous_integration/</guid><description>Is the concept of running [see page 43, all] the tests of a software system every time new-code is added to the system. If any of the tests fail the new changes are rejected until everything is running at 100%. This ensures that developers know when an error was caused by a recent change because the suite was fully passing the last time it was run.</description></item><item><title>Continuous Word Representations</title><link>https://mohkale.gitlab.io/brain/20201025205208-continuous_word_representations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025205208-continuous_word_representations/</guid><description>Is the process of converting words to vectors in a way which can capture semantic meaning.
word2vec offers representation fo word meaning that is much richer than any other term-weighting scheme (binary, tfm, tfidf).
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Proposes techniques to pre-train fixed length vectors for every word from very large corpora. In CWR each word is represented by a vector itself, rather than VSMs approach of plotting the word as an axis in some n-dimensional coordinate space.</description></item><item><title>Contract Dischargement</title><link>https://mohkale.gitlab.io/brain/20201018223629-contract_dischargement/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018223629-contract_dischargement/</guid><description>The process by which a contract can be ended.
Performance of the Contract The terms of the contract have been satisfied.
Agreement of Contractual Parties Both parties agree to disolve the contract, mutually.
Breach of Contract A violation of the terms of a contract. This can [see page 4, either ]be a:
Repudiatory breach - breach of primary obligation, not warranty (warranty is a secondary condition) Anticipatory breach - specifying in advance you can't perform as agreed (such as promising to deliver by friday but only being able to deliver by next monday).</description></item><item><title>Contract Law</title><link>https://mohkale.gitlab.io/brain/20201001230919-contract_law/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201001230919-contract_law/</guid><description>Contract law is a kind of Law (civil, not criminal domain). The strength of an authority in the law will depend having like facts and precedence established in higher courts.
What constitutes like facts is subjective.
Two very able advocates trying to persuade the court that the strength of authority supports their case rather than the opposition Contract law is subject to the principle of Privity: Generally, only the parties to the contract can enforce it.</description></item><item><title>Contract vs. Tort</title><link>https://mohkale.gitlab.io/brain/20201114183708-contract_vs_tort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114183708-contract_vs_tort/</guid><description>How a tort of negligence [see page 4, differs] from a contract.
A contract aims to enforce a promise, a tort establishes a general guideline of standards (eg. Do not harm your neighbour). A contract tries to protect a persons economic prosperity, a tort aims to protect from other sorts of harm.
The repudiation for both is often to pay damages, however whereas contract damages tries to give the victim what the contract promises; Tort damages simply tries to get the victim to their original position as far as possible.</description></item><item><title>Contradiction</title><link>https://mohkale.gitlab.io/brain/20210627000232-contradiction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627000232-contradiction/</guid><description>Is a proposition that [see page 24, must] be false.
These propositions have a truth table that's always false.</description></item><item><title>Control Theory</title><link>https://mohkale.gitlab.io/brain/20210927014416-control_theory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210927014416-control_theory/</guid><description>Is a [see page 35, domain] of science concerned with the control of dynamic systems.
Modern control theory aims to design systems that maximise an objective function over time. This relates strongly to adaptive intelligence.
They viewed purposive behaviour as arising from a regulatory mechanism trying to minimise &amp;quot;error&amp;quot; - the difference between the current state and the goal state.
It remains distinguished from AI despite the stark similarities between the two because control theory is heavily driven by calculus and matrix algebra where as orthodox AI was founded in part to escape these perceived limitations.</description></item><item><title>Controller Card</title><link>https://mohkale.gitlab.io/brain/20210717015920-controller_card/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717015920-controller_card/</guid><description>Is a card that plugs into a motherboard to give access to devices such as a hard drives, CD-ROM drives or floppy disks.
Some devices can be run by specialised chipsets directly on the motherboard, whereas others are too simple to need a controller card (example: keyboard).</description></item><item><title>Convergence</title><link>https://mohkale.gitlab.io/brain/20210220185552-convergence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220185552-convergence/</guid><description>Diverging is when a numerical sequence diverges away from a common solution and continually gives bigger and less accurate solutions. Converging is when a sequence stabilises to a fixed number (root value) after a misc number of iterations. Continuing the sequence only provides a better approximation of the root, and we often stop once we reach an accurate value.
For example consider the first few values of the recurrence relation \( x_{n+1} = \frac{x_n^5+3}{5} \) beginning with \( x_0 = -1.</description></item><item><title>Convolution</title><link>https://mohkale.gitlab.io/brain/20201116232758-convolution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201116232758-convolution/</guid><description>Describes how the area of the overlap of two discrete sample sequences changes with respect to time (or sample count for discrete inputs). We calculate this as an [see page 8, integral] of the product of the two functions (or a summation if our input is continuous).
\[ h[n] * x[n] = \sum_{i}{h[i] \times x[n-i]} \]
Note: Take special note of the fact that we aren't plotting the product of two discrete points, were plotting the area of overlap of the two spectrums for each given offset i.</description></item><item><title>Convolutional Filter</title><link>https://mohkale.gitlab.io/brain/20201109162034-convolutional_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109162034-convolutional_filter/</guid><description>Refers to the [see page 14, weights] used for weighting in a moving-average calculation.
Filters can be called non-zero over its region of support to mean that the filter is 0 everywhere outside of the window its being used in.
Filters are often normalised so that it sums to 1.0 (avoids a filter producing a completely different color than was put input to it).
Note: most filters are symmetric.</description></item><item><title>Convolutional Neural Network</title><link>https://mohkale.gitlab.io/brain/20210301041211-convolutional_neural_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210301041211-convolutional_neural_network/</guid><description>Are neural networks based on [see page 12, identifying] patterns in images.
[see page 12, Go]: was cracked using a deep convolutional neural network where the state of the board is passed as a 19x19 image. The network was trained on BCM to detect and respond to possibly dangerous patterns in the image.</description></item><item><title>Convoy Effect</title><link>https://mohkale.gitlab.io/brain/20211009140031-convoy_effect/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009140031-convoy_effect/</guid><description>Is the effect when a process take up a lot of the CPU time, leaving other processes with potentially smaller resource needs following like a convoy behind them. This is mainly an issue when designing schedulers.</description></item><item><title>Coordinate Systems</title><link>https://mohkale.gitlab.io/brain/20201017160538-coordinate_systems/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201017160538-coordinate_systems/</guid><description>A convention for how to align coordinate axes in a system.
These conventions are often visualised using our hands with:
Finger Axis Thumb Y First Z Index X Note: When demonstrating have our thumb point upwards and then determine the direction of the other two axes from there.
See here for a visual indication of the axes for both left and right hand coordinate systems.</description></item><item><title>Coprime</title><link>https://mohkale.gitlab.io/brain/20210830223523-coprime/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830223523-coprime/</guid><description>Refers to two numbers \( a \) and \( b \) if the only positive integer that is a divisor of both of them is 1. That is to say the greatest common divisor of both of them is 1, \( \gcd(a, b) \).
We describe coprimes \( a, b \) as a is coprime with b or a is prime to b.
For example 14 and 25 are coprime since \( \gcd(14, 25) = 1 \) whereas 14 and 21 are not coprime because \( \gcd (14, 21) = 7 \).</description></item><item><title>Copy Elision</title><link>https://mohkale.gitlab.io/brain/20220301091825-copy_elision/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220301091825-copy_elision/</guid><description>Is a compiler optimisation technique where the return value of a function isn't copied into the memory of the caller function, instead the address of the object in the called function will be equivalent to the address in the caller function.
This works relatively well for basic functions where the control flow is predictable, but for more complex or involved routines copy elision may not be applicable.</description></item><item><title>Coreference Resolution</title><link>https://mohkale.gitlab.io/brain/20201110210310-coreference_resolution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110210310-coreference_resolution/</guid><description>The ability to [see page 23, identify] context in a piece of text. eg. &amp;quot;This is an iphone&amp;quot;, &amp;quot;it is great&amp;quot;. what is &amp;quot;it&amp;quot;? The general problem is resolving aliases or synonyms for the same term in different contexts.</description></item><item><title>Correlation</title><link>https://mohkale.gitlab.io/brain/20210130042222-correlation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130042222-correlation/</guid><description>Is a measure of how correlated two variables are. The goal is to take a collection of paired-data and return an integer in the range \( -1 \leq i \leq 1 \) to indicate how correlated the data is.
For example when we plot them on a scatter-diagram if a change in \( x \) leads to a consistent positive change in \( y \) then we say the two variables are positively correlated.</description></item><item><title>Correlation Attack</title><link>https://mohkale.gitlab.io/brain/20210215043045-correlation_attack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215043045-correlation_attack/</guid><description>A form of attack on stream ciphers which [see page 31, exploits] the approximate linear-relationship between a combining functions inputs and outputs.
Example with a Geffe generator A correlation attack on a Geffe generator works based on the following assumptions. We have:
An endless amount of bits from the input \( i \) and output-stream \( b \) The truth table of the combining function (Geffe generator) The tap sequence of each LFSR feeding the Geffe generator.</description></item><item><title>Correlation Matrix</title><link>https://mohkale.gitlab.io/brain/20210220043839-correlation_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220043839-correlation_matrix/</guid><description>Describes the [see page 21, correlation] between a collection of neurons.
For two neurons \( i,j \) the [see page 22, correlation] between them is defined as the average of the product of their output potential over a certain sample range: \[ C_{kj} = \langle v_k v_j \rangle = \frac{1}{P} \sum_^{P} v_k^{\mu} v_j^{\mu} \] The superscript \( \mu \) references the potential of the subscript neuron at time/sample \( \mu \).</description></item><item><title>Cosine Correlation</title><link>https://mohkale.gitlab.io/brain/20201109232148-cosine_correlation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109232148-cosine_correlation/</guid><description>Calculates the correlation between an input signal and some cosine signal (of known frequency).
\[ S_p = \sum^{N-1}{S_n \times \cos(\frac{2 \pi n p}{N})}, p = 0\ldots{N-1} \] Where:
\(S_n\) is some arbitrary signal \(s\). \(\cos(\frac{2 \pi n p}{N})\) Note: This is just the correlation function with the second signal parameterised as a cosine.
Basis for Correlation For two sinusoids, \(s, t\) where:
The period of one is a multiple of the number of periods in the other The sample range N is defined such that it occurs over a whole number of cycles for both signals.</description></item><item><title>Cost</title><link>https://mohkale.gitlab.io/brain/20201029233140-cost/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201029233140-cost/</guid><description>Is a resource sacrificed or foregone to achieve a specific objective. [see page 4, costing] is the gathering of cost information and it's attachment to cost objects.
Costs can be [see page 5, classified] by:
Class Meaning Function Organisational functions (eg. production, marketing etc.) Element Why incur a cost? (eg. Buying raw materials. paying for labour). Nature Direct vs Indirect cost.</description></item><item><title>Counter Mode</title><link>https://mohkale.gitlab.io/brain/20210216013949-counter_mode/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216013949-counter_mode/</guid><description>A Variant of OFM which produces subsequent-blocks by incrementing the initial-block instead of reusing the output-block from previous encryptions.
Decryption is identical to encryption except with plaintext substituted with ciphertext.</description></item><item><title>Counting Sort</title><link>https://mohkale.gitlab.io/brain/20210628053820-counting_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053820-counting_sort/</guid><description>Is a linear time stable sorting algorithm that works by [see page 15, counting] the number of occurrences in the input array. Assuming the values to be sorted are non-negative integers in the range \( \{ 0, \ldots, k \} \) counting sort keeps an array \( C[0 \ldots k] \) to count elements and an array \( B[1 \ldots n] \) to write the sorted array back.
Formulation def counting_sort(arr): k = max(arr) out = [0 for _ in arr] mem = [0 for _ in range(k)] for j in range(len(arr)): mem[arr[j]] += 1 for i in range(1, k): mem[i] = mem[i] + mem[i - 1] for j in reversed(range(len(arr))): mem[arr[j]] -= 1 out[mem[arr[j]]] = arr[j] Code Snippet 1: Counting sort implementation.</description></item><item><title>Coupling</title><link>https://mohkale.gitlab.io/brain/20210626234831-coupling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234831-coupling/</guid><description>A design metric that [see page 32, measures] how strong the inter-connections between cohesive components are. Loose/[see page 33, weak] coupling is desirable and means changing a component is unlikely to affect other components.
Shared variables or control information exchange lead to tight/strong coupling.</description></item><item><title>Covariance Matrix</title><link>https://mohkale.gitlab.io/brain/20210220193332-covariance_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220193332-covariance_matrix/</guid><description>Is a transformation matrix [see page 5, defined] using the covariance of each pair of dimensions in a sample-space. Transforming with the covariance matrix has the affect of centring the data around the mean.
We define the covariance between two neurons \( kj \) as: \[ C^0_{kj} = \langle (x_k - \langle x_k \rangle)(x_j - \langle x_j \rangle) \rangle \]
Note: The variance is the covariance of an element and itself.</description></item><item><title>Covert Channels</title><link>https://mohkale.gitlab.io/brain/20210211235307-covert_channels/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211235307-covert_channels/</guid><description>Using shared resources (channel) to communicate (leak information) in an unexpected way.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } It's generally possible to identify unusual means of communicating via elements of the system so that the intent of the [mandatory policy](/brain/20210211230047-mandatory_access_control/) is broken. These means are known as [see page 25, [covert channels](com3501-w01-MAC)]. Covert channels arise because subjects share resources, which can allow one subject (the transmitter) to modulate how another subject (the receiver) observes the system.</description></item><item><title>CPP</title><link>https://mohkale.gitlab.io/brain/20210124010427-cpp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210124010427-cpp/</guid><description>Is a low level programming language and exists as the mostly backwards-compatible successor to C.
Initially standardised in 1998, c++ has had several revisions. A minor revision in 2003, followed by a large overhaul in 2011 and gradual improvements every 3 years from then on-wards.
Deviations from C Function Overloading and Name Mangling The CPP compiler mangles the names of any identifiers and symbols in the produced object files. This is to handle functional overloading, where a function can be declared with different types and the compiler can resolve the correct function depending on the argument types.</description></item><item><title>CPU</title><link>https://mohkale.gitlab.io/brain/20210717185409-cpu/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717185409-cpu/</guid><description>TODO: CPU.</description></item><item><title>Crawling</title><link>https://mohkale.gitlab.io/brain/20201109160027-crawling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109160027-crawling/</guid><description>The affect where the line orientation of our screen-space alters the degree of jaggedness of our samples.
Simulating [see page 3, smooth] edges in a pixel sample grid produces a jagged pattern, but if the lines are oriented differently we may end up with more or less jaggedness.</description></item><item><title>CRC Card Prototyping</title><link>https://mohkale.gitlab.io/brain/20210914042459-crc_card_prototyping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210914042459-crc_card_prototyping/</guid><description>Is a low-tech [see page 5, strategy] to prototype useful object concepts.
The general [see page 6, technique] is:
Use 15cm x 10cm file index cards (this sizes forces decomposition). Write the name of each candidate class on a card. Write down 2-7 responsibilities of this class. If the card has no responsibilities, delete it. If it has too many responsibilities [see page 8, split] them into two new sub-cards.</description></item><item><title>Criminal Law</title><link>https://mohkale.gitlab.io/brain/20201001232527-criminal_law/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201001232527-criminal_law/</guid><description> Rules set out by society for all our benefit. Legal action is brought about by the state (CPS). Any fines imposed in relation to an infringment are paid to the state. State must show the defendent is guilty beyond a reasonable doubt</description></item><item><title>Cryptanalysis</title><link>https://mohkale.gitlab.io/brain/20210215003640-cryptanalysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215003640-cryptanalysis/</guid><description>The [see page 3, process] of analysing a cryptographic system to break its protection.</description></item><item><title>Cryptographic System</title><link>https://mohkale.gitlab.io/brain/20210215004345-cryptographic_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215004345-cryptographic_system/</guid><description>Is a [see page 4, system] in cryptography which takes a plaintext input, encrypts it using a key to produce some ciphertext and can decrypt the ciphertext using maybe a different key to retrieve the original plaintext.
\begin{align*} \text{Ciphertext} &amp;amp;= \text{Encryption}(\text{Plaintext}, \text{Key1}) \
\text{Plaintext} &amp;amp;= \text{Decryption}(\text{Ciphertext}, \text{key2}) \end{align*}
With \( Key1 \) being the public key and \( Key2 \) being the private key.
The security of a cryptographic-system depends on the secrecy of the key/s, not the specific encryption/decryption algorithm.</description></item><item><title>Cryptography</title><link>https://mohkale.gitlab.io/brain/20210214235805-cryptography/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210214235805-cryptography/</guid><description>The science of [see page 3, secret writing], making something that is legible, illegible.</description></item><item><title>Cubic Equation</title><link>https://mohkale.gitlab.io/brain/20210621221120-cubic/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621221120-cubic/</guid><description>Is an equation of the form \( y = ax^3 + bx^2 + cx + d \).
Solving a Cubic The common approach to finding the roots of a cubic is to find one root, then factorise it out of the expression and solve the remaining quadratic. How we find the root can be done through an exhaustive search or perhaps plotting it and observing where the curve falls to 0.</description></item><item><title>Culling</title><link>https://mohkale.gitlab.io/brain/20201106225709-culling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106225709-culling/</guid><description>The process of removing polygons facing away from the camera relative to the orientation of each polygon and the camera.
We do this using an [see page 10, equation] based on the polygon normal, the line of sight vector for the camera and the angle between them.
\[ N_p . S = |N_p| |S| cos \theta \]
A polygon is only visible if \(N_p . S \gt 0\) where:
\( S \) is the line of sight vector (can be just any vertex on the polygon).</description></item><item><title>Cumulative Distribution Function</title><link>https://mohkale.gitlab.io/brain/20210622163839-cumulative_distribution_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622163839-cumulative_distribution_function/</guid><description>We define the Cumulative Distribution Function \( F(x_0) \) as the sum of the probabilities (values of the probability density function) up-to \( X = x_0 \) for a discrete random variables.
\begin{align} F(X_0) &amp;amp;= \sum_{x \leq x_0} P(X = x) \label{rand-var-cumulative} \end{align}
Note: from this definition \( F(x_{\text{max}}) = 1 \).</description></item><item><title>Curse of Dimensionality</title><link>https://mohkale.gitlab.io/brain/20201125175759-curse_of_dimensionality/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201125175759-curse_of_dimensionality/</guid><description>A general point of difficulty in building machine-learning systems [see page 2, where] a high dimensional-space with a modest number of samples is mostly empty. Furthermore the more classes we need to consider, the more features we'll need to consider.
The main problem is given a binary classifier we can generally pretty easily separate terms into either class. Adding another class to this (now ternary classifier) means we:
Must introduce every term that may be associated with that class to our feature vectors.</description></item><item><title>CVC Sequence</title><link>https://mohkale.gitlab.io/brain/20210129045448-cvc_sequence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129045448-cvc_sequence/</guid><description>A CVC (Consonant-(/brain/20201020203400-vowels/)-Consonant) [see page 4, sequence] corresponds to the opening and closing of the mouth. We define a CV-skeleton as the see page 4, sequence in a word.</description></item><item><title>Cyber Crime</title><link>https://mohkale.gitlab.io/brain/20210317182158-cyber_crime/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210317182158-cyber_crime/</guid><description>Is a [see page 2, crime] that involves a computer and a network.
Can be subdivided into:
Cyber-dependent crimes: Computers are the tool and target. Cyber-enabled crime: Traditional crimes increased in scale or reach by the use of a computer (example: fraud existed before computers but is much more rampant with them). Examples Computer as a [see page 3, tool]:
Phishing Spam Computer used to plan a traditional crime Fraud (example: painting replicated and sold at original price) Computer as a [see page 4, target]:</description></item><item><title>Cybernetics</title><link>https://mohkale.gitlab.io/brain/20210927015550-cybernetics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210927015550-cybernetics/</guid><description>Is a control-theory discipline concerned with circular causality (or feedback systems) where the outcomes of actions are taken as inputs for further actions.</description></item><item><title>Cycle</title><link>https://mohkale.gitlab.io/brain/20210622174212-cycle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174212-cycle/</guid><description>In relation to a graph, a cycle is a closed path, I.E. the end vertex of the last edge is the start vertex of the first edge.</description></item><item><title>Cylinder Head Sector</title><link>https://mohkale.gitlab.io/brain/20210813235930-cylinder_head_sector/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210813235930-cylinder_head_sector/</guid><description>TODO: https://en.wikipedia.org/wiki/Cylinder-head-sector
An archaic block addressing system later deprecated by logical block addressing.</description></item><item><title>Daemon</title><link>https://mohkale.gitlab.io/brain/20210717024815-daemon/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717024815-daemon/</guid><description>Is a long-running background process.
Note: The name daemon is taken from Maxwell's demon.
They are daemons because it's often easier to write one program that runs constantly and knows about all requests than it would be to try to make sure that a flock of copies (each processing one request and all running at the same time) don't step on each other.</description></item><item><title>Data Destruction</title><link>https://mohkale.gitlab.io/brain/20210415004922-data_destruction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415004922-data_destruction/</guid><description>An anti-forensics process that [see page 10, wipes] the system/drive to erase data (files) or metadata (time-stamps).
This can be done using:
Secure file shredders (SpyBot shredders) System cleaners (Evidence eliminator, CCleaner) Meta-data tamperers</description></item><item><title>Data Encryption Standard</title><link>https://mohkale.gitlab.io/brain/20210215070605-data_encryption_standard/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215070605-data_encryption_standard/</guid><description>The most widely-known and [see page 7, controversial] block cipher algorithm based on a Feistel network, using a 56-bit key (64-bit with check-bits).
DES was issued in 1976 and has been the first choice for commerce (example banking) since.
[see page 15, Operation] Permute the 64-bit input block (this is the Initial Permutation). Split it into two 32-bit left and right blocks. Pass each through 16 rounds of processing, each using some 48-bit subkey.</description></item><item><title>Data Hiding</title><link>https://mohkale.gitlab.io/brain/20210415005034-data_hiding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415005034-data_hiding/</guid><description>An anti-forensics process which works by making evidence harder to find by [see page 12, obscuring] its storage. This can include scrambling the data (encryption) or moving its storage into slack-space to evade detection.
Can be subdivided into:
Data in transit through a network such as using SSH, SSl/TLS, ToR Data at rest in your hard-disk [see page 14, Basic] Techniques Modifying file extensions (store an executable as a png image file) Include random garbled text to evade hash based signature detection Store text such that it appears invisible when opened (example: word document with white foreground and background text).</description></item><item><title>Data Normalisation</title><link>https://mohkale.gitlab.io/brain/20210216035414-data_normalisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216035414-data_normalisation/</guid><description>Refers to [see page 12, transforming] all the points in a collection by the same amount. The goal here is to better distribute clusters of the same classes away from each other, which helps the learning process.</description></item><item><title>Data Segment</title><link>https://mohkale.gitlab.io/brain/20210717194224-data_segment/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717194224-data_segment/</guid><description>Is the writable area of a processes memory space where the processes local variables and other data is kept. This is divided into two sub-parts: The initialised data segment and the uninitialised data segment.
Initialised Data Segment Containing all of a programs global and static variables. This starts at a fixed size because the size of all these variables can be determined at compile time.
The values for these variables are initially stored within the read-only memory (typically within the code segment) and are copied into the data segment during the start-up routine of the program.</description></item><item><title>Data Space</title><link>https://mohkale.gitlab.io/brain/20210220191738-data_space/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220191738-data_space/</guid><description>Is the coordinate-space where data samples are mapped to.
In a classic machine-learning system we have samples of data supplied as vectors with each field in the vector corresponding to some dimension in data-space. For example a sample set of flowers with the fields:
Petal-length Leaf-color Height Will be supplied as a set of 3 length vectors with \( X_0 \) being the petal-length for sample \( X \), \( X_1 \) being the leaf-color, etc.</description></item><item><title>Data Structure</title><link>https://mohkale.gitlab.io/brain/20210628052639-data_structure/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628052639-data_structure/</guid><description>Refers to the core data types available in algorithms.</description></item><item><title>Database Denormalisation</title><link>https://mohkale.gitlab.io/brain/20210815024415-database_denormalization/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815024415-database_denormalization/</guid><description>Is the act of un-(/brain/20210815023015-database_normalisation/) a database. This could be [see page 22, valuable] to increase the efficiency of searches (fewer joins) or to decrease the fragmentation of data (fewer tables).
Denormalisation can be done by:
Reducing the number of tables.
Approaches involve avoiding reconstructing whole objects in memory from fragmented table data, resulting in fewer joins.
Flattening the database structure into one table leading to wasted space due to excess null values.</description></item><item><title>Database Normal Forms</title><link>https://mohkale.gitlab.io/brain/20210815024227-database_normal_forms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815024227-database_normal_forms/</guid><description>Is a standard for database normalisation relying on a systematic list of step-by-step [see page 16, instructions].
We should generally aim for at least 3NF to get a good separation of data. If a multi-valued dependency exists than 4NF is needed.</description></item><item><title>Database Normalisation</title><link>https://mohkale.gitlab.io/brain/20210815023015-database_normalisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815023015-database_normalisation/</guid><description>Is the process of optimising the data-model for a relational database in the interest of minimising data duplication (maximising space efficiency) or optimising database lookup (read/search speeds).</description></item><item><title>Database Optimisation</title><link>https://mohkale.gitlab.io/brain/20201127021359-database_optimisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127021359-database_optimisation/</guid><description>Various approaches to speed up database access at the cost of memory or with the introduction of other problems.
SQL Tuning Denormalisation Reduce the number of tables (and introduce more redundancy) to speed up data-access. Less joins, less indirect access, quicker performance.</description></item><item><title>Database Replication</title><link>https://mohkale.gitlab.io/brain/20201127023230-database_replication/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127023230-database_replication/</guid><description>Is a way to support highly available systems by duplicating databases.
There's a few different shapes this approach can take but the general advantages are availability in numbers. You have multiple databases that can be queried in parallel, meaning you can distribute incoming load across multiple hosts.</description></item><item><title>Database System</title><link>https://mohkale.gitlab.io/brain/20210815014800-database_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815014800-database_system/</guid><description>Is the idea of a large store of see page 3, data.
While programs in memory have rich data-types (arbitrary classes), with dynamically expandable data (linked lists or heap allocation) and support for object references through memory pointers, programs in databases have a slue of other concerns. The data has to be simply typed and stored into a pre-defined set of tables. These tables can grow to accommodate new records but cannot support new fields.</description></item><item><title>DBMS</title><link>https://mohkale.gitlab.io/brain/20220201171320-dbms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201171320-dbms/</guid><description>Is software that oversees the operation of a database.</description></item><item><title>Deadlock</title><link>https://mohkale.gitlab.io/brain/20211008004331-deadlock/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008004331-deadlock/</guid><description>Is a problem in multi-threaded systems where the system cannot make any forward progress because all the threads are blocked or sleeping.
For low-priority systems such as user OSs or it may be more efficient to allow deadlocks however for critical systems (example Apollo 13) we need a system that tracks, breaks or prevents deadlocks.
The OS can interrupt any system call to potentially break a deadlock. It can also make some files read-only to make them shareable across threads.</description></item><item><title>Decibels</title><link>https://mohkale.gitlab.io/brain/20210128044840-decibels/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128044840-decibels/</guid><description>The logarithmic ratio between the sound-pressure of a given sound-wave and a reference value \(p_ref\).
Sound pressure is commonly measured using [see page 4, Pascals]. The range of human hearing ranges from around \(20/1*10^6\) pascals upto ear-splitting at \(20\) Pascals. This huge range is really inconvenient to work with so we commonly use decibels instead.
\(0 dB\) is commonly [see page 6, scaled] to be the threshold of human hearing, with \(140 dB\) being the threshold of pain.</description></item><item><title>Decision Boundary</title><link>https://mohkale.gitlab.io/brain/20210216040014-decision_boundary/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216040014-decision_boundary/</guid><description>Refers to the line/surface/boundary which a classifier draws to seperate two objects of a different class.
Linear Decision Boundary A decision boundary is considered linear if it can be represented by a straight-line or surface.</description></item><item><title>Decision Making</title><link>https://mohkale.gitlab.io/brain/20201114220835-decision_making/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114220835-decision_making/</guid><description>Future costs change under different options.
A cost is relevant in decision making when:
It relates to the main objective of the business (increase wealth). It must relate to future cost. It must vary depending on a certain decision. See worked through [see page 7, example].</description></item><item><title>Declarative Languages</title><link>https://mohkale.gitlab.io/brain/20220102171457-declarative_languages/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220102171457-declarative_languages/</guid><description>A class of 5th generation languages where a program specifies what computation is to be done. Example ML, Prolog, Haskell.</description></item><item><title>Deduction</title><link>https://mohkale.gitlab.io/brain/20210626235229-deduction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626235229-deduction/</guid><description>Is the process of [see page 29, inferring] facts from true propositions using propositional connectives.
Deduction is a process with 3 steps:
Start from premises (true propositions). Construct an inference from these; This gives conclusions, as a truth value. Babies Can't Manage Crocodiles example As an [see page 42, example] deduction:
Consider the premises:
Babies are illogical (\( B \implies I \)). Nobody is despised who can manage a crocodile (\( M \implies \neg D \)).</description></item><item><title>Deep Feed-Forward Neural Network</title><link>https://mohkale.gitlab.io/brain/20210216040309-deep_feed_forward_neural_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216040309-deep_feed_forward_neural_network/</guid><description>An extension of single layer perceptrons, where we can have an [see page 3, arbitrary] number of intermediate layers between the input and output layers. We colloquially refer to all layers hidden in the middle of the input and output layers as hidden-layers.
Training Training a multi-layer perceptron is much the same as a single layer perceptron except when we alter the weights for one layer, say \( n-2 \), we must consider how that change affects the error for layer \( n-1 \) and \( n \) because:</description></item><item><title>Deep Reinforcement Learning</title><link>https://mohkale.gitlab.io/brain/20210430014901-deep_reinforcement_learning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430014901-deep_reinforcement_learning/</guid><description>Using deep neural-networks in a reinforcement neural network problem. This allows us to encode more complex states in our input and therefore learn and respond to more distinct behaviour.
The idea behind [see page 4, deep RL] is to combine deep learning and Temporal Difference learning.
Can be seen as taking supervised learning concepts into reinforcement learning.
Our [see page 6, goal] is to learn the weights that will best learn the expected rewards Q.</description></item><item><title>Demand</title><link>https://mohkale.gitlab.io/brain/20201127004905-demand/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127004905-demand/</guid><description>The number of users, requests, transactions etc. that a system is expected to receive over a given period of time.
You should design a system such that you always meet (and even exceed) demand.</description></item><item><title>Denary</title><link>https://mohkale.gitlab.io/brain/20210716032753-denary/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210716032753-denary/</guid><description>Is the most common notation for representing numbers using base-10.
Digits in denary range from [0-9], with each equating an increasing or lowering power of 10 across the decimal point. For example the denary number 45.6 can be seen as \( 45.6 = 4 \times 10^1 + 5 \times 10^0 + 6 \times 10^{-1} \).</description></item><item><title>Dense Graph</title><link>https://mohkale.gitlab.io/brain/20210628020523-dense_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628020523-dense_graph/</guid><description>Is a graph where the number of edges is roughly \( |V|^2 \).</description></item><item><title>Deployment Diagram</title><link>https://mohkale.gitlab.io/brain/20210906011316-deployment_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906011316-deployment_diagram/</guid><description>Is a UML diagram modelling the deployment of the physical system. This could relate to the number of processors, or the configuration of the networks.
It's used to show the allocation of software artifacts (exe, dll, src, xml, doc, jar, etc. units of software that have to be delivered) to available hardware. Configurations are shown using associations.
\begin{figure} \centering \begin{tikzpicture} \umlclass{WebServer} {Apache Tomcat 5.5}{}; \umlclass[below right=1cm of WebServer]{WebClient} {Google Chrome 6.</description></item><item><title>Depth First Search</title><link>https://mohkale.gitlab.io/brain/20210628060359-depth_first_search/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628060359-depth_first_search/</guid><description>Is an algorithm for [see page 7, traversing] all the nodes of a graph. It works by exploring recursively down to the root of each node, before back tracking up and exploring sibling nodes.
time = 0 def dfs(g): global time time = 0 for v in g.vertices(): v.color = white v.search_parent = None for u in g.vertices(): if u.color == &amp;#39;white&amp;#39;: dsf_visit(g, u) def dfs_visit(g, u): global time time += 1 u.</description></item><item><title>Derivatives</title><link>https://mohkale.gitlab.io/brain/20210311203403-derivatives/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210311203403-derivatives/</guid><description>The gradient at a point on a curve is defined as the gradient of the tangent to the curve at that point. We define the gradient-function as the function that gives this gradient value. The process of finding the gradient of a function is called differentiation.
For a function \( f(x) \) we call the its derivative \( \frac{\delta f(x)}{\delta x} = f'(x) \).
Take for example an arbitrary 2D function with a curve \( y = f(x) \) and pick two points \( (x_i, f(x_i)) \) on it.</description></item><item><title>Design Metrics</title><link>https://mohkale.gitlab.io/brain/20210626234621-design_metrics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234621-design_metrics/</guid><description>A class of metrics aimed around the high-level [see page 27, design] of a system. Examples of design considerations include:
Weighted methods per class. Depth of the inheritance tree. Number of children. Coupling between object classes. Cohesion in methods.</description></item><item><title>Design Pattern</title><link>https://mohkale.gitlab.io/brain/20210922043804-design_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922043804-design_pattern/</guid><description>Are reusable [see page 10, elements] of object oriented design.</description></item><item><title>Detecting Light Intersection</title><link>https://mohkale.gitlab.io/brain/20201023204646-detecting_light_intersection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023204646-detecting_light_intersection/</guid><description>We can use an [see page 24, approach] similair to phong illumination to detect whether light is incident on a surface.</description></item><item><title>Determinant</title><link>https://mohkale.gitlab.io/brain/20210621223050-determinant/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621223050-determinant/</guid><description>The determinant of a square Matrix \( A \) is \( |A| \) and is a scalar value that is a function of the entries of the matrix.
For a 2D matrix \( \begin{pmatrix} a &amp;amp; b \\ c &amp;amp; d \end{pmatrix} \), this is \[ \det(A) = ad - bc \]
TODO: Describe 3D matrix.</description></item><item><title>Deterministic Algorithm</title><link>https://mohkale.gitlab.io/brain/20210628053318-deterministic_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053318-deterministic_algorithm/</guid><description>An algorithm that behaves deterministically.</description></item><item><title>Diagonalisation</title><link>https://mohkale.gitlab.io/brain/20210220195646-diagonalisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220195646-diagonalisation/</guid><description>Along some direction there's only variance.</description></item><item><title>Diagram Coding</title><link>https://mohkale.gitlab.io/brain/20201102002738-diagram_coding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102002738-diagram_coding/</guid><description>A dictionary based coding scheme using an 8-bit [see page 3, dictionary]. The first 7-bits (128 characters) are the same as they are in ASCII and the remaining 128 combinations are for common letter pairs (as, and, pre etc.).</description></item><item><title>Dictionary Text Compression</title><link>https://mohkale.gitlab.io/brain/20201102003326-dictionary_text_compression/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102003326-dictionary_text_compression/</guid><description>A form of text compression reliant on replacing word fragments with dictionary entries. Store the key for an entry instead of the entry itself to save space.
This approach has issues because:
Words common to many texts are pretty short (not much to optimise). Dictionaries are suited for specific texts, not for others. An english dictionary isn't much use for a french text. The main concerns with building a dictionary based solution are:</description></item><item><title>Difference Equation</title><link>https://mohkale.gitlab.io/brain/20210131005833-difference_equation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131005833-difference_equation/</guid><description>A filtering-equation defined in terms of the current input and the output of the filter at an earlier point in time. For [see page 3, example]: \[ y[n] = ay[n-1] + x[n] \] where \( y[n] \) is the output of the filter at time \( n \), \( x \) is the signal and \( m \) is some scalar we use in this specific equation applied to the output of the filter at an earlier time \( y[n-1] \).</description></item><item><title>Differential Cryptanalysis</title><link>https://mohkale.gitlab.io/brain/20210216004729-differential_cryptanalysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216004729-differential_cryptanalysis/</guid><description>A attack that works by exploiting how differences in the input to a cipher affects the outputs of the cipher.
discover where the cipher exhibits non-random behavior, and exploiting such properties to recover the secret key.</description></item><item><title>Differential Equation</title><link>https://mohkale.gitlab.io/brain/20210621210847-differential_equation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621210847-differential_equation/</guid><description>Refers to an equation consisting of \( x, y \), and \( \frac{\,dy}{\,dx} \).
Solving a differential equation (also known as fining the general solution) means getting it into the form \( y = f(x) \). The general approach to this is to get the left hand side consisting only of \( y \) and \( \,dy \) and the right side consisting only of \( x \) and \( \,dx \).</description></item><item><title>Diffuse Maps</title><link>https://mohkale.gitlab.io/brain/20201108005048-diffuse_maps/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201108005048-diffuse_maps/</guid><description>A way to specify the diffuse value for a fragment based on the fragments position on the object.
This is not too dissimilar to texture-mapping, we simply provide a texture mapping on to the objects surface indicating what the color value should be at that point. The specular and ambient values remain the same meaning the brightness of the object isn't changed by this step.
See here.</description></item><item><title>Digital Circuits</title><link>https://mohkale.gitlab.io/brain/20210627010111-digital_circuits/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010111-digital_circuits/</guid><description>Refers to circuits composed of several components, each with a binary output.
Basic Gates (AKA: Basic Units) Are the base level components used to build more [see page 9, complex] circuits.
Table 1: Basic circuits circuits/gates derived directly from boolean algebra (see see page 44, [here]). Gate Symbol And \andgate Or \orgate Not \notgate The behaviour of each of these gates can be modelled by truth tables.</description></item><item><title>Digital Evidence</title><link>https://mohkale.gitlab.io/brain/20210306154812-digital_evidence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210306154812-digital_evidence/</guid><description>Digital [see page 4, facts or signs] that are of value to an investigation. The [see page 10, value] of digital evidence comes from the ubiquity of digital devices in modern day use, ranging from communication, obfuscation and preparation/planning for crimes.
Any data stored or transmitted using a computer that can support or refute a theory of how an offence occurred or address critical elements of the offence such as intent or alibi.</description></item><item><title>Digital Forensics</title><link>https://mohkale.gitlab.io/brain/20210306153520-digital_forensics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210306153520-digital_forensics/</guid><description>The [see page 3, process] of collecting, examining, analysing and reporting of digital evidence (sometimes involved in cyber crime) without any damage.
Digital forensics is the detection, extraction and preservation of digital evidence from digital media that is accurate, authentic and admissible as evidence in a court of law.
The [see page 5, principles] of digital forensics are:
The crime-scene has to be frozen, evidence must be collected early and without contamination.</description></item><item><title>Digital Image</title><link>https://mohkale.gitlab.io/brain/20210317182525-digital_image/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210317182525-digital_image/</guid><description>Creating a digital clone or reference copy of data-storage medium such as a hard-disk or a computers RAM. This is key part of preservation &amp;amp; collection for digital-forensics.
Includes not only files visible to the OS but every bit of data, every sector, partition, files, folders, master boot records, deleted files and un-allocated spaces.
[see page 3, Variants]:
Disk to image: Copy disk to a binary image file which can be loaded as a virtual disk.</description></item><item><title>Digital Rights Management</title><link>https://mohkale.gitlab.io/brain/20210211223308-digital_rights_management/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211223308-digital_rights_management/</guid><description/></item><item><title>Digital Signals</title><link>https://mohkale.gitlab.io/brain/20201102164209-digital_signal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102164209-digital_signal/</guid><description>Digital signals are analogue signals that've been quantised.
Speech signals are typically:
quantised in amplitude sampled in time</description></item><item><title>Digital to Analogue</title><link>https://mohkale.gitlab.io/brain/20201102165124-digital_to_analogue/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102165124-digital_to_analogue/</guid><description>The inverse of quantisation, we convert digital signals back to analogue representations so they can be played.
This often [see page 3, involves] multiple transistors passing an amplitude through to a speaker.</description></item><item><title>Digraph</title><link>https://mohkale.gitlab.io/brain/20210622174403-digraph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174403-digraph/</guid><description>Is a graph where the edges have a direction associated with them.
The edges in this case are known as directed edges.</description></item><item><title>Dijkstra's Algorithm</title><link>https://mohkale.gitlab.io/brain/20210622175126-dijkstra_s_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622175126-dijkstra_s_algorithm/</guid><description>Is an algorithm to find the shortest path from a given start node to every other node in a graph.
Formulation Ordinarily the algorithm works by defining a box containing three sub-boxes over each node. \tikz \draw (0,0) rectangle (2,1) (1,1) -- (1, 0.5) (0, 0.5) -- (2, 0.5); The top left box contains the order of labelling, as in the iteration index at which we finalised a path from to this vertex.</description></item><item><title>Dipthongs</title><link>https://mohkale.gitlab.io/brain/20210129064246-dipthongs/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129064246-dipthongs/</guid><description>A sound formed by the combination of two vowels in a single syllable, in which the sound begins as one vowel and moves towards another (as in coin, loud, and side).
A digraph representing the sound of a diphthong or single vowel (as in feat). A compound vowel character; a ligature (such as \(\ae\)).</description></item><item><title>Directional Light</title><link>https://mohkale.gitlab.io/brain/20201108010559-directional_light/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201108010559-directional_light/</guid><description>A light source that exists independent of its location.
When light is modelled to be coming from infinitely far away, all of its light rays have the same direction. Where the light is doesn't matter, only the direction of incoming rays.
The light rays are said to be parallel to each other.</description></item><item><title>Directory</title><link>https://mohkale.gitlab.io/brain/20211010184459-directory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010184459-directory/</guid><description>Is a file-system entry that can contain a hierarchy of files.
Like files there are system calls provided to open, read and close directories, however there isn't a sys-call for writing to a directory (since that implies creating a file or a link).
Note: On UNIX the readdir function always includes . and .. for the current and parent directories. Warn: readdir is not thread-safe.
int exists(char *dir, char *name) { struct dirent *dp; int found = 0; DIR *dirp = opendir(dir); while ((dp = readdir(dirp)) !</description></item><item><title>Discontinue Decision</title><link>https://mohkale.gitlab.io/brain/20201114230538-discontinue_decision/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114230538-discontinue_decision/</guid><description>The decision to stop/[see page 24, discontinue] a product-line.
In the example take note of how if we remove one line we apportion the fixed costs between the remaining two products and lead to lower profit for all 3 product lines.
For this decision we must also consider: Whether the facilities used for the product can/cannot be used for other products. Even if the facilities cannot be used so long as their inclusion helps cover in fixed costs and leads to net positive profit then they should be included.</description></item><item><title>Discrete Cosine Transform</title><link>https://mohkale.gitlab.io/brain/20210201040352-discrete_cosine_transform/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210201040352-discrete_cosine_transform/</guid><description>Models a sequence as a sum of cosine components and acts as a real-value approximation to the DFT.
\[ c_n = \sqrt{\frac{2}{P}} \sum_^{P}{m_i \cos{[\frac{n(i - \frac{1}{2})\pi}{P}]}} \]
Where \( P \) is the number of filterbank channels.
C Description \(c_0\) is a measure of the signal energy across all frequencies \(c_1\) is a measure of the ratio between high and low frequencies \(c_2\) is the ratio between high/low and mid frequencies etc.</description></item><item><title>Discrete Log Problem</title><link>https://mohkale.gitlab.io/brain/20210429002434-discrete_log_problem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429002434-discrete_log_problem/</guid><description>The problem that there is no efficient algorithm for computing the discrete logs \( \mod p \) in general.
That is to say if we have three numbers \( m \), \( n \), \( g \) and a sufficiently large prime number \( p \), we can't find \( m \) or \( n \) from \( {g}^{mn} \mod p \) in an efficient amount of time.</description></item><item><title>Discrete Random Variables</title><link>https://mohkale.gitlab.io/brain/20210622163357-discrete_random_variables/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622163357-discrete_random_variables/</guid><description>If we conduct an experiment with a discrete (finite) number of outcomes \( x \) then these outcomes can be thought of as a random variable \( X \).
Note: We use the uppercase letter \( X \) to refer to the random variable itself and the lower-case variant \( x \) to refer to a particular outcome of \( X \).
For example in a game 3 coins are thrown and the number of heads counted.</description></item><item><title>Discrete Uniform Distribution</title><link>https://mohkale.gitlab.io/brain/20210622164258-discrete_uniform_distribution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622164258-discrete_uniform_distribution/</guid><description>For a discrete random variable \( X \) where \( X \) is defined over a set of distinct values that're all equally likely. I.E. \( P(X = x_i) = \frac{1}{n}, \; i = 1, 2, 3, \dots, n \)
An example of a discrete uniform distribution is the roll of a dice. There're 6 outcomes and each are equally likely.
From this we can define:
\begin{align} E(X) &amp;amp;= \frac{n+1}{2} \</description></item><item><title>Discretionary Access Control</title><link>https://mohkale.gitlab.io/brain/20210211224039-discretionary_access_control/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211224039-discretionary_access_control/</guid><description>A form of access control in which the user [see page 3, specifies] who is given what access to what objects they control. Implemented with:
passwords capabilities (tickets) owner/group/other masks Access Control Lists Warn: This approach is vulnerable to trojan horses, however some protection can be made with MAC.
Note: This is a minimum requirement for many military systems and at a high-level is essentially just a [see page 46, military-obsession].</description></item><item><title>Disjoint Sets</title><link>https://mohkale.gitlab.io/brain/20210627000813-disjoint_sets/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627000813-disjoint_sets/</guid><description>Two sets \( A \) and \( B \) are [see page 35, disjoint] if they don't have any elements in common: \( A \cap B = \varnothing \).</description></item><item><title>Disk Block</title><link>https://mohkale.gitlab.io/brain/20211010180608-disk_block/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010180608-disk_block/</guid><description>Is a portion of a disk that is reserved for storing the contents of a file or directory. Most file-systems refer to portions of a hard disk in terms of blocks.
You can think of a block as a contiguous region on disk, the size of which is often determined by some property of the underlying hardware but more frequently based on the size of a page in memory (to allow disk data to be cached in memory for faster access).</description></item><item><title>Disk Memory</title><link>https://mohkale.gitlab.io/brain/20210717215229-disk_memory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717215229-disk_memory/</guid><description>Refers to a persistent memory store such as a hard-disk or optical drive.
Disk Partitions The disk is divided by the OS into partitions with each partition being a continuous span of blocks, each distinct from any other partition. The lowest partition is often treated as a boot partition where a kernel can be placed to be booted.
Disk Failures Are measured using Mean-Time-To-Failure (MTTF). If the MTTF for a single disk is 30,000 hours, then the MTTF for 1000 disks is \( \frac{30000}{1000} = 30 \text{hours} \).</description></item><item><title>Displacement Mapping</title><link>https://mohkale.gitlab.io/brain/20201109204141-displacement_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109204141-displacement_mapping/</guid><description>An alternative to bump-mapping which stores the height field of a surface in a texture map. This approach actually alters the geometry of an object, unlike bump-mapping.
The key advantage of this approach is a proper [see page 34, silhouette] for the mapped object, even for shadows.
Disadvantages Slower than bump mapping. Relies on the geometry of the object being detailed enough to support.</description></item><item><title>Distributed System</title><link>https://mohkale.gitlab.io/brain/20201127014456-distributed_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127014456-distributed_system/</guid><description>A distributed system, also known as distributed computing, is a system with multiple components located on different machines that communicate and coordinate actions in order to appear as a single coherent system to the end-user.</description></item><item><title>Divide &amp; Conquer</title><link>https://mohkale.gitlab.io/brain/20210628051637-divide_conquer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628051637-divide_conquer/</guid><description>Is an algorithm building approach where we:
Divide: break the problem into smaller sub-problems (smaller instances of the original problem). Conquer: Solve these problems recursively. Combine: The solution to sub-problems into the solution for the original problem.</description></item><item><title>Dividend</title><link>https://mohkale.gitlab.io/brain/20210113043528-dividend/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210113043528-dividend/</guid><description>The distribution of cash or other assets to shareholders is called a dividend. Dividends reduce retained earnings but they are not an expense.
Definitely, the amount of dividends paid to the shareholders is not determined by a certain rate but it is a decision of the board of administrators, ratified by the shareholders in the ordinary general assembly meeting.</description></item><item><title>Docker</title><link>https://mohkale.gitlab.io/brain/20220201142755-docker/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201142755-docker/</guid><description>Is a cross platform container management framework.
Dockerfile Describes the step-by-step process of constructing a container image.
This involves mounting any local directories into the container, installing any base packages or dependencies, and specifying a base image to inherit any defaults from.
# Use archlinux as the base image.FROMarchlinux# Install any python pip dependencies.RUN python3.10 -m pip install termcolor# Set the working directory for any of the following RUN, CMD, ENTRYPOINT, COPY and# ADD instructions.</description></item><item><title>Docker Compose</title><link>https://mohkale.gitlab.io/brain/20220201142807-docker_compose/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201142807-docker_compose/</guid><description>Is a wrapper around docker which simplifies container orchestration and multi-image management. At a high level docker-compose lets you configure multiple services and the dependencies between them so you can reliably spin up an execution environment for them.
Note: Docker compose also allows communication between containers through a private network exposed only to the current docker-compose project. Each service acts as a logical host in the network. To take full advantage of this you must declare what ports are exposed by a service either in docker-compose.</description></item><item><title>Domain</title><link>https://mohkale.gitlab.io/brain/20210627010415-domain/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010415-domain/</guid><description>The set of accepted inputs for a function.
This could be defined as a cartesian product, allowing the function take multiple input parameters.</description></item><item><title>Domain</title><link>https://mohkale.gitlab.io/brain/20210719223052-domain/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719223052-domain/</guid><description>Refers to a collection of machines that share a common name suffix. Domains can live inside other domains, for example www.tldp.org lives in the .tldop.org subdomain of the .org domain.
Domain Name Is a human-readable identifier for a given host within a domain.
Format A domain name is a case-insensitive series of labels all joined together by a full-stop. Each label of a domain-name can divide the domain into subdomain, with the right-most domain being the most encompassing.</description></item><item><title>Domain Name</title><link>https://mohkale.gitlab.io/brain/20210719192933-domain_name/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719192933-domain_name/</guid><description/></item><item><title>Domain Name System</title><link>https://mohkale.gitlab.io/brain/20210719201639-domain_name_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719201639-domain_name_system/</guid><description>Refers to the collection of programs and databases that co-operate to resolve a host-name to an IP-address.
The DNS system is defined in a hierarchy of domain-name servers arranged as a inverted tree. At the top of the tree are the root servers for TLDs. Each name-server knows the IP addresses for the domains directly beneath them and so on and so forth.
DNS is carefully designed so that each machine can get away with the minimum amount of knowledge it needs to have about the shape of the tree, and local changes to subtrees can be made simply by changing one authoritative server's database of name-to-IP-address mappings.</description></item><item><title>Dot Product</title><link>https://mohkale.gitlab.io/brain/20201120234503-dot_product/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120234503-dot_product/</guid><description>Is a transformation of two n-sized vectors into a real-valued number.
We can define the dot-product between 2 vectors as the summation of the multiplication of each element in the vectors zipped together.
\begin{align} \label{eq:dotproduct-sum} \vec{a} \cdot \vec{b} = \sum_^{n} a_i \times b_i \end{align}
We can also define the dot-product of two vectors as a measure of the angle between them.
\begin{align} \label{eq:dotproduct-cosine} \cos \theta = \frac{\vec{d_1} \cdot \vec{d_2}}{|\vec{d_1}| |\vec{d_2}|} \end{align}</description></item><item><title>Double Entry Concept</title><link>https://mohkale.gitlab.io/brain/20210112212338-double_entry_concept/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210112212338-double_entry_concept/</guid><description>The idea that the assets equation always balances out.
For example if we buy a car we lose equity in the cash we've spent but gain liabilities in a car with equal value to the lost cash.</description></item><item><title>Drawing a Triangle</title><link>https://mohkale.gitlab.io/brain/20201023011733-drawing_a_triangle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023011733-drawing_a_triangle/</guid><description>After creating an opengl window the first thing to get started on is drawing a triangle. There's a few stages to this so lets work through them in order.
Specify Coordinates Firstly we need to let OpenGL know what we're trying to draw. We do this by supplying coordinates in normalised device coordinates.
Here are the coordinates for a 2D triangle. Note the z axis is set to \(0\) so it's pointing directly towards you.</description></item><item><title>Drawing Methods</title><link>https://mohkale.gitlab.io/brain/20201105172022-drawing_methods/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201105172022-drawing_methods/</guid><description>OpenGL has a few drawing functions which're useful for different purpose.
glDrawArrays This draws the vertices from a vertex-array-object from some start vertex to some end vertex. You can specify how the arrays are drawn. see here.
glDrawArrays( GL_TRIANGLES, // How the vertices are to be drawn 0, // Which vertex to start drawing from 3 // How many vertices to draw ); Note: This approach required 3 vertices, ommitting or supplying an incomplete triangle skips it drawing for it.</description></item><item><title>Duty of Care</title><link>https://mohkale.gitlab.io/brain/20201114184339-duty_of_care/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114184339-duty_of_care/</guid><description>A legal [see page 6, obligation] to maintain a reasonable care in the performance of an act that could cause harm to others. (eg. You can't sell a soft drink if it's deadly.)
See the [see page 7, neighbour principle].
The duty of care is either based on precedent or:
Analogising the current case to previous cases. Using the [see page 8, Caparo test]. Other Kinds of Loss Damages for physical injury are pretty common, but for other kinds of loss it varies.</description></item><item><title>Dynamic Programming</title><link>https://mohkale.gitlab.io/brain/20210628054725-dynamic_programming/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054725-dynamic_programming/</guid><description>An algorithm design method where we solve and [see page 7, cache] the values of smaller sub-problems to solve the larger problem. Dynamic programming is usually efficient if the problem has an optimal substructure and the sub-problem space is small.</description></item><item><title>Dynamic Security Testing</title><link>https://mohkale.gitlab.io/brain/20210607025033-dynamic_security_testing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607025033-dynamic_security_testing/</guid><description>An approach to test computer software security by directly having an automated program emulate an attacker interacting with the system.
Might:
Destroy/corrupt your database (by testing SQL injections) Violate compliance policies (granting access to data you shouldn't see). This approach [see page 9, requires]:
IT department approval Dedicated test systems and infrastructure Necessary expertise</description></item><item><title>Dynamic Set</title><link>https://mohkale.gitlab.io/brain/20210628053909-dynamic_set/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053909-dynamic_set/</guid><description>Is a set like data structure.
Table 1: see page 3, [Operations] on sets. Method Description Search(S,k) Returns the element x with key k or null. Insert(S,k) Adds an element x to S. Delete(S,k) Removes the element x from S. Successor(S, x) Return the next eleement to x in S. Predecessor(S, x) Return the next eleement to x in S.</description></item><item><title>Dynamical Stability</title><link>https://mohkale.gitlab.io/brain/20210301031403-convergence_stability/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210301031403-convergence_stability/</guid><description>We define stability as when an gradient descent equation is stable to perturbations at convergence points.
Recall convergence can [see page 7, happen] either when we reach a peak or minima in the weight/time spectrum. Observe that for a minima if we add some small constant it (moving it along the weight/time spectrum) we can continue traveling down the negative gradient and return back to the minima. For a maxima however the negative gradient will only push us further away from the maxima and towards a minima.</description></item><item><title>Echo-Return-Loss-Enhancement</title><link>https://mohkale.gitlab.io/brain/20210131235936-echo_return_loss_enhancement/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131235936-echo_return_loss_enhancement/</guid><description>Is a (performance) [see page 16, measure] of the ratio of the power of a signal before and after acoustic-echo-cancelation.
The recommended value for this by the ITU-T G.167 is 40 dB, with a maximum delay of AEC being 2ms (meaning if you wait longer than this than the input could've changed and the calculation results are no longer relevant).</description></item><item><title>EEPROM</title><link>https://mohkale.gitlab.io/brain/20210811040138-eeprom/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811040138-eeprom/</guid><description>Electrically EPROM.</description></item><item><title>Eigenvector</title><link>https://mohkale.gitlab.io/brain/20210220185158-eigenvector/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220185158-eigenvector/</guid><description>An [see page 9, eigenvector] is a mathematical relation between vector and matrix multiplication that's equivalent to a scalar transformation of the input vector. \[ w \times C = w \times \lambda \] Here multiplying the vector \( w \) by the matrix \( C \) is equivalent to scaling the vector \( w \) by the scalar \( \lambda \).
We call in this case the:
vector \( w \) the eigenvector scalar \( \lambda \) the eigenvalue.</description></item><item><title>Electroglottograph</title><link>https://mohkale.gitlab.io/brain/20210129003427-electroglottograph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129003427-electroglottograph/</guid><description>A tool used to measure the buzzing sound produced by the larynx.
It should appear like [see page 5, this].</description></item><item><title>Electrolarynx</title><link>https://mohkale.gitlab.io/brain/20210129003207-electrolarynx/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129003207-electrolarynx/</guid><description>An artificial larynx (electrolarynx) that can artificially produce the buzzing caused by the vocal-cords. These are used in cases where the larynx needs to be removed (eg. Throat Cancer).</description></item><item><title>Electronic Code Book</title><link>https://mohkale.gitlab.io/brain/20210216013103-electronic_code_book/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216013103-electronic_code_book/</guid><description>A mode of use for block-ciphers which [see page 7, maps] each input block with the same value to the same output-block using a codebook key.
This approach is useful because any error in a block affects [see page 38, only] the decryption of that block.
When one of the transmitted bits in a block has an error (0 read as 1 or vice-versa) that blocks decryption may fail but the rest of the sequence can still be [see page 35, decrypted] accurately without issue.</description></item><item><title>Element Buffer Objects</title><link>https://mohkale.gitlab.io/brain/20201023024505-element_buffer_objects/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023024505-element_buffer_objects/</guid><description>Is a way to compactly represent a collection of points in less memory using vertex-buffer-objects.
Why? For example a rectangle can be represented using 2 triangles:
float vertices[] = { // first triangle 0.5f, 0.5f, 0.0f, // top right 0.5f, -0.5f, 0.0f, // bottom right -0.5f, 0.5f, 0.0f, // top left // second triangle 0.5f, -0.5f, 0.0f, // bottom right -0.5f, -0.5f, 0.0f, // bottom left -0.</description></item><item><title>Elementary Row Operations</title><link>https://mohkale.gitlab.io/brain/20210623023529-elementary_row_operations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210623023529-elementary_row_operations/</guid><description>Refers to the operations you can perform on simultaneous equations in matrix notation to help solve the simultaneous equation. These include:
Multiplying a row by a scalar. Swapping the position of 2 rows. Add a multiple of one row onto another. Simultaneous Equations Representing Simultaneous Equations example First we should establish how you can represent a collection of simultaneous equations in matrices. Consider the simultaneous equations
\begin{align*} x + 4y + z &amp;amp;= 9 &amp;amp; 8x + y + 5z &amp;amp;= 35 &amp;amp; 2x - 2y -z &amp;amp;= 2 \end{align*}</description></item><item><title>Encapsulation</title><link>https://mohkale.gitlab.io/brain/20210924030501-encapsulation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210924030501-encapsulation/</guid><description>Is a fundamental concept in OOP where we apply both information hiding and modular protection. This is done by attaching access-specifiers to class members such as private, protected, package or public. Attributes are often made private or protected (exposed to sub-classes) and methods are public or protected.</description></item><item><title>Encoding</title><link>https://mohkale.gitlab.io/brain/20210215020701-encoding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215020701-encoding/</guid><description>An early [see page 8, form] of cryptography which uses strings of symbols (from a codebook) to stand for complete messages. For example The egg is in the pan could substitute the egg for the team of militants and the pan for the strikezone.</description></item><item><title>Encryption</title><link>https://mohkale.gitlab.io/brain/20210214235910-encryption/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210214235910-encryption/</guid><description/></item><item><title>End Point Detection</title><link>https://mohkale.gitlab.io/brain/20210130040003-end_point_detection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130040003-end_point_detection/</guid><description>Refers to detecting the [see page 7, points] at which speech begins or ends.
This is often done using:
short-time-energy (voiced speech) zero-crossing-rate (unvoiced speech).</description></item><item><title>Endianness</title><link>https://mohkale.gitlab.io/brain/20210811040631-endianness/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811040631-endianness/</guid><description>Refers to the order in which a sequence of bits is translated into memory. In general this just means which bit of a sequence stores the most significant bit (largest value).
In general a computers CPU will work equally well regardless of the choice in endianness because the hardware will consistently use the same endianness. This only becomes an issue when moving data external to the computer such as when transferring between different computers or inspecting the internal computer bytes from a memory dump and expecting a given endianness.</description></item><item><title>Enigma Machine</title><link>https://mohkale.gitlab.io/brain/20210215024418-enigma_machine/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215024418-enigma_machine/</guid><description>Is an cryptographic system designed as a poly-alphabetic substitution cipher around the use of [see page 13, 3-rotors] that change after every character is digested. Each rotation of any one of the rotors alters the cipher for the next character.
The actual mechanism of the machine has one rotor move after every character is inserted, the second move only once the first rotor has made a complete revolution and the final rotor only after the second has made a complete revolution.</description></item><item><title>Entity Relationship Model</title><link>https://mohkale.gitlab.io/brain/20210814224257-entity_relationship_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210814224257-entity_relationship_model/</guid><description>Is a UML model to [see page 8, represent] structured concepts as entities with associated attributes and then establish relationships between them using n-ary relationships.
ERM diagrams are most likely to map to database tables. The structure of an ERM diagram is the same as a class diagram.
Variants Extended ERM builds on ERM by supporting generalisation relationships as well (class super/sub type). UML builds even further on this supporting aggregation relationships (whole/part) and operations between entities (services/methods).</description></item><item><title>Entity Relationship Modelling</title><link>https://mohkale.gitlab.io/brain/20210815023121-entity_relationship_modelling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815023121-entity_relationship_modelling/</guid><description>Is a form of database normalisation based on simple diagrammatical [see page 8, analysis].
The steps are:
[see page 9, Merge] tables that're in a 1:1 relationship (removes the need for a join). Link tables that're in a 1:M relationship (from M→1). Introduce a new [see page 10, linker] table to encapsulate each M:N relationship yielding two new 1:M relationships (from M→1). The primary key of the linker table should be a composite key of the intermediate tables.</description></item><item><title>Environment Mapping</title><link>https://mohkale.gitlab.io/brain/20201109194820-environment_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109194820-environment_mapping/</guid><description>Is an alternative to texture-mapping where an objects surface [see page 5, reflects] the environment it's placed in.
See here for the history of environment mapping.
Think: mirror, astronaut helmet, shiny utensils.
This can be used to create complex CG effects like the T-1000, even in [see page 15, real world] scenes.
The general [see page 6, idea] is for each ray of light intersecting on an object, we reflect the ray (equidistant to the normal) and pick the color that ray then intersects with in the world.</description></item><item><title>Environmental Law</title><link>https://mohkale.gitlab.io/brain/20210109015209-environmental_law/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210109015209-environmental_law/</guid><description>The area of law that seeks to manage human impacts on the [see page 4, environment].
There's a general tension between whether the environment should be protected because it's inherently useful or only so far as the environment is useful to us. The rightness of environmental law is a matter of power and political persuasion.
See [see page 6, sources] of environmental law.
Principles Is based on [see page 5, four] main principles.</description></item><item><title>Epic</title><link>https://mohkale.gitlab.io/brain/20210626234145-epic/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234145-epic/</guid><description>Is are large bodies of work that can be broken down into a number of smaller stories.
For [see page 13, example]:
A job user can post a CV. A job seeker can submit a CV that includes only basic information such as name, address and work history. A job seeker can submit a CV with all the information an employer may want to see. When slicing an epic into stories you should [see page 14, consider]:</description></item><item><title>Epoch</title><link>https://mohkale.gitlab.io/brain/20210206064426-epoch/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206064426-epoch/</guid><description>A hyper-parameter specifying the number of times that a learning algorithms will work through the entire training dataset.
Defined as a single iteration through all the data points in a sample set, in terms of one-or-more batches.
One epoch means that each sample in the training dataset has had an opportunity to update the internal model parameters.
We generally use epochs to specify how many times the training data should be processed before we stop the learning process (as an alternative to stopping when the error drops below a certain threshold (which it may never actually reach)).</description></item><item><title>EPROM</title><link>https://mohkale.gitlab.io/brain/20210811040110-eprom/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811040110-eprom/</guid><description>Erasable Programmable ROM.</description></item><item><title>Epsilon-Greedy Reward Policy</title><link>https://mohkale.gitlab.io/brain/20210415002202-epsilon_greedy_reward_policy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415002202-epsilon_greedy_reward_policy/</guid><description>A reward policy which uses a random value (\(\epsilon\)) to influence action selection.
The exact algorithm is taking the greedy action with probability \( 1 - \epsilon \) and any other random action with probability \( \epsilon \).
\( \epsilon \) could start very high and then decrease over iterations.</description></item><item><title>Equity</title><link>https://mohkale.gitlab.io/brain/20210112040622-equity/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210112040622-equity/</guid><description>Amounts [see page 25, owed] by the company to owners/stakeholders (includes profits) in the forms of shares. I.E. it's the owners claims on the total companies assets.
This is defined as ordinary share capital (value per share) and reserve funding.
See [see page 41, here] for how different factors can affect equity and the definition of:
share capital-ordinary revenues expenses dividends</description></item><item><title>Equivalence Class</title><link>https://mohkale.gitlab.io/brain/20210627015203-equivalence_class/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627015203-equivalence_class/</guid><description>For an equivalence relation \( R \subseteq A \times A \) the equivalence class of \( a \in A \) with respect to \( R \) is the set of elements related to \( a \) by \( R \). \[ [a]_R = \{ x \in A : a R x \} \]
Set of Equivalence Classes For an equivalence relation \( R \) the set of equivalence classes of \( A \) with respect to \( R \) is a partition of \( A \).</description></item><item><title>Equivalence Relation</title><link>https://mohkale.gitlab.io/brain/20210627014910-equivalence_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627014910-equivalence_relation/</guid><description>Is a homogeneous relation that is reflexive, symmetric and transitive. See [see page 17, here].</description></item><item><title>Euclid's Algorithm</title><link>https://mohkale.gitlab.io/brain/20210830230628-euclid_s_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830230628-euclid_s_algorithm/</guid><description>Is an algorithm for finding the greatest common divisor of two integers, \( a, b \).
def gcd(a, b): if a &amp;lt; b: a, b = b, a while b != 0: a, b = b, a % b return a Code Snippet 1: Implementation of euclids algorithm. Procedure The algorithm proceeds in a series of steps where the output of the last step is used as the input for the next one.</description></item><item><title>Euclidean Distance</title><link>https://mohkale.gitlab.io/brain/20210621191719-euclidean_distance/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621191719-euclidean_distance/</guid><description>Is a measure of the distance between two points in some \( n \) dimensional space.
For example if the two points are \( p \) and \( q \):
\begin{align} l = \sqrt{\sum_{i}^{n} (p_i - q_i)^2} \end{align}
Similarly if we just want to find the distance between two points, we can calculate the distance of the vector between them:
\begin{align} l = \sqrt{(p_1 - q_1)^2 + (p_2 - q_2)^2} \end{align}</description></item><item><title>Euler Angles</title><link>https://mohkale.gitlab.io/brain/20201107025350-euler_angles/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201107025350-euler_angles/</guid><description>4 Angles that can represent any orientation in 3D.
Angle Axis Meaning Roll X how much we roll (think a plane diving while spinning)? Pitch Y how much we're looking up or down? Yaw Z magnitude we're looking to the left or to the right?</description></item><item><title>Eulerian Graph</title><link>https://mohkale.gitlab.io/brain/20210622180410-eulerian_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622180410-eulerian_graph/</guid><description>A route starting and finishing at different vertices \( X \) and \( Y \) and passing over each edge once is only possible if \( X \) and \( Y \) have an odd Degree and all the other vertices have an even degree. A graph with this property is known as semi-eulerian. If \( X = Y \) and the route must end where it began, then all vertices must have an even degree.</description></item><item><title>Eulers Formula</title><link>https://mohkale.gitlab.io/brain/20210130061443-eulers_formula/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130061443-eulers_formula/</guid><description>Is a mathematical formula relating trigonometric and complex exponential functions.
\[ e^{ix} = \cos(x) + i \times \sin(x) \]</description></item><item><title>Eulers Theorem</title><link>https://mohkale.gitlab.io/brain/20210902233845-eulers_theorem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210902233845-eulers_theorem/</guid><description>States that given \( n \) being a positive integer and \( a \) being an integer that is relatively prime to \( n \) then: \[ a^{\Phi(n)} \equiv 1 \mod n \] where \( \Phi(n) \) is the eulers totient function.</description></item><item><title>Eulers Totient Function</title><link>https://mohkale.gitlab.io/brain/20210902211724-euler_s_totient_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210902211724-euler_s_totient_function/</guid><description>Is a function that counts that number of positive integers less than a given integer \( n \) that are coprime to \( n \). \[ \Phi (n) = |\{ m \in \mathbb{N} : 1 \leq m &amp;lt; n \land \gcd (m) = 1 \}| \]
In the special case that \( n \) is prime, \( \Phi(n) = n-1 \), because \( n \) has no factors other than 1 and itself.</description></item><item><title>Event Extraction</title><link>https://mohkale.gitlab.io/brain/20201210185858-event_extraction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201210185858-event_extraction/</guid><description>[see page 28, Identify] all reports of event instances, typically in a small-set of classes.
can be divided into:
Task Meaning Event detection find all mentions of events in a text Event classification assign a class to the detected event [see page 31, Challenges] Events can be thought of as relations between entities (attending the event) however they can be shown to be more complex.</description></item><item><title>Everything is a File</title><link>https://mohkale.gitlab.io/brain/20211010184600-everything_is_a_file/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010184600-everything_is_a_file/</guid><description>You may have encountered the old UNIX adage: Everything is a File. This describes the fact that in most UNIX systems file operations provide an interface to abstract many different operations. Network sockets, hardware devices, objects on the disk, etc. are all represented by file like objects.
The File API A file like object must follow the following conventions:
It must present itself to the file system. It must support common file-system operations such as open, read, write.</description></item><item><title>Excitation</title><link>https://mohkale.gitlab.io/brain/20210128061517-excitation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128061517-excitation/</guid><description>Driving a wave form by supplying it with energy.
Each kind of excitation is applied by classic types of music instruments matching the variations of sound Variations of sound waves:
Type Sound Type Example Percussion Impulsive Drum Wind Noisy Flute String Repetitive Violin</description></item><item><title>Excitory Post Synaptic Potential</title><link>https://mohkale.gitlab.io/brain/20210206062124-excitory_post_synaptic_potential/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206062124-excitory_post_synaptic_potential/</guid><description>The spike in potential (voltage) in the synapse of a neuron from a dendrite. For a standalone spike this is a [see page 6, curve] that increases rapidly then decays slowly.</description></item><item><title>Exec</title><link>https://mohkale.gitlab.io/brain/20211002211625-exec/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002211625-exec/</guid><description>Is a system-call that allows you replace a running process image with a new process image. See exec. Warn: Exec isn't a reversible process. Once you exec you can't restore the previous program or its state afterwards.
Table 1: Suffixes in the exec family of functions and their meaning. tbl:exec-sfx Suffix Description e Accepts an array of pointers to environment variables for the new process.</description></item><item><title>Existential Quantification</title><link>https://mohkale.gitlab.io/brain/20210627005922-existential_quantification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627005922-existential_quantification/</guid><description>Is a quantification \[ \exists x \; P(x) \] which [see page 18, reads] as &amp;quot;there exists an \( x \) for which the predicate P(x) holds&amp;quot;. In this expression the free-variable \( x \) is bound by the quantifier \( \exists x \).
If the predicate is true for some value the truth-set must not be empty. If the predicate is not true for some value the truth set is a strict subset of the universe of discourse (and may be the empty set).</description></item><item><title>Expert Systems</title><link>https://mohkale.gitlab.io/brain/20200705003008-expert_systems/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200705003008-expert_systems/</guid><description>Seperate the knowledge of a system (in the form of rules), from the reasoning component.
Expert a systems are an application of strong AI.
An example of a strong AI system is DENDRAL, an AI to determine the underlying structure of a molecule from some experimental data on it. Knowledge of the common substructures a molecule may have greatly reduced the search space of possible structures, improving the complexity of the search problem.</description></item><item><title>Exponent</title><link>https://mohkale.gitlab.io/brain/20210621192258-exponent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621192258-exponent/</guid><description>Refers to the multiplication of a number by itself a certain number of times. We say a number \( x \) raised to the power \( y \) is equivalent to \( x^y = x \times x \times \dots \times x = \prod^{y} x \).
The special case of
\( y = 2 \) is known as squaring. \( y = 3 \) is known as cubing. Rules of Powers Raising to the power can have different affects depending on the value of \( x \) and \( y \).</description></item><item><title>Exponential Moving Average</title><link>https://mohkale.gitlab.io/brain/20210531004031-exponential_moving_average/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210531004031-exponential_moving_average/</guid><description>Is a [see page 16, way] of measuring the average of a collection of values, as the values are calculated (as opposed to calculating all of them and then averaging at the end).
\begin{align} \label{eq:original} \tau \frac{\Delta \bar{x}}{\Delta t} &amp;amp;= - \bar{x} + x \
\label{eq:eulers-method} \bar{x}_{n+1} - \bar{x}_n &amp;amp;= - \frac{\Delta t}{\tau} \bar{x}_n + \frac{\Delta t}{\tau} x_n \
\bar{x}_{n+1} &amp;amp;= ( 1 - \frac{\Delta t}{\tau} ) \bar{x}_n + \frac{\Delta t}{\tau} x_n \</description></item><item><title>External Cache</title><link>https://mohkale.gitlab.io/brain/20210717215048-external_cache/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717215048-external_cache/</guid><description>Is a kind of memory that's off-chip.</description></item><item><title>External Constraints</title><link>https://mohkale.gitlab.io/brain/20210906010911-external_constraints/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906010911-external_constraints/</guid><description>Constraints outside of the domain of building the current system. For example compatibility with existing systems.</description></item><item><title>External Fragmentation</title><link>https://mohkale.gitlab.io/brain/20211002233934-external_fragmentation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002233934-external_fragmentation/</guid><description>Refers to a state in malloc where even though we collectively have enough unreturned memory to satisfy a request, it's split up so finely between returned blocks that there's no way to return it.
For example we could have a series of blocks 2KiB, 4KiB, 2Kib where the first and last blocks are free for allocation. If a call for 3KiB comes up we have 4KiB of free space in total but not in a series so we end up having to allocate at least 1KiB more memory for it.</description></item><item><title>Extreme Programming</title><link>https://mohkale.gitlab.io/brain/20210626220945-extreme_programming/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626220945-extreme_programming/</guid><description>Is an agile methodology that divides tasks to be developed into small story cards. The developers and client then agree which story cards need to be done by the next release.
In general XP doesn't adhere to any particular language but it's more suited to OOP.
XP adheres rigorously to testing. Before writing any code you should write [see page 25, test cases]. These test cases replace the formal spec of the system and the system is validated by executing the test.</description></item><item><title>Facial Animation</title><link>https://mohkale.gitlab.io/brain/20201120223636-facial_animation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120223636-facial_animation/</guid><description>Describing the motions of a face.
There are various approaches to this but many take the approach of using a parametric-curve and interpolate parameters (eg. vertex position) over time.
[see page 25, Interpolate Vertex Positions] Make shape. Move vertices in shape to create a new pose for a new frame. Repeat. Store changes between frames as a PC and interpolate between them. Warn: There is the issue of [see page 8, scrambling] when moved positions of the face scrambling together and making a mess.</description></item><item><title>Factual vs. Subjective Data</title><link>https://mohkale.gitlab.io/brain/20201110204625-factual_vs_subjective_data/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110204625-factual_vs_subjective_data/</guid><description>Two [see page 19, classifications] for data found in text.
Facts Something that is known to have happened (or exist) for which there's proof.
It costed 500 dollars. Warn: This is hard because sentences can express opinion indirectly.
Subjective A thought, belief, judgement etc. about something or someone.
this experience was the wordst. Warn: this is hard because sentences don't always have +ve or -ve opinions. (eg. they will refund me).</description></item><item><title>Fail Over</title><link>https://mohkale.gitlab.io/brain/20201127022809-fail_over/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127022809-fail_over/</guid><description>Is a way to support highly available systems by having multiple servers act as fallbacks for the main one.
This can come in 2 varieties:
Active Passive - Heartbeats between active and passive server, passive takes over (including actives Ip) once active stops responding. Active Active - Both servers manage traffic, spreading the load between them. Downsides:
More hardware, more complexity. Chance for data loss if active crashes while working on request and passive takes over.</description></item><item><title>Fake Shadows</title><link>https://mohkale.gitlab.io/brain/20201027190056-fake_shadows/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027190056-fake_shadows/</guid><description>A form of shadow which [see page 5, approximates] the position and shape of a shadow from the center/anchor of an object.
We simply add a tiny dark region directly below the object. This approach requires no calculations but needs flat ground and isn't very exact.</description></item><item><title>fcntl</title><link>https://mohkale.gitlab.io/brain/20211010031342-fcntl/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010031342-fcntl/</guid><description>Is a system-call that allows you perform operations on open files. See fcntl.
This can be used for example to change the flags for a file-descriptor to make it non-blocking.</description></item><item><title>Feature Extraction</title><link>https://mohkale.gitlab.io/brain/20201110211426-feature_extraction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110211426-feature_extraction/</guid><description>Extract object features that have been commented on in a piece of text.</description></item><item><title>Feature Selection</title><link>https://mohkale.gitlab.io/brain/20210220192751-feature_selection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220192751-feature_selection/</guid><description>Finding the [see page 3, optimal] transformations such that we can minimise the loss of information when truncation our new data.</description></item><item><title>Feature Space</title><link>https://mohkale.gitlab.io/brain/20210220192139-feature_space/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220192139-feature_space/</guid><description>Is a coordinate system (often mapped to from sample space) in which correlation is reduced (variation is increased) as much as possible.
The goal of feature-space is essentially to find a set of axes in which correlation is as small as possible. Note that correlation is bad. Information is repeated across different feature/dimensions and when training a system it needs to detect and disregard this overlap lest dealing with unintended biases.</description></item><item><title>Feistel Cipher</title><link>https://mohkale.gitlab.io/brain/20210216012024-feistel_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216012024-feistel_cipher/</guid><description>Is a [see page 18, theoretical-model] for a block cipher based on the idea of the repeated application of reversible rounds.
Rounds Each [see page 16, round] has the same general format. For each round with input block \( {L}_{j-1}, {R}_{j-1} \) we produce the output:
\begin{align*} {L}_{j} &amp;amp;= {R}_{j-1} \
{R}_{j} &amp;amp;= {L}_{j-1} \xor f({R}_{j-1}, {K}_{j}) \
\end{align*}
With \( k_j \) being the subkey for the current round and \( f \) being some function.</description></item><item><title>Fibonacci Numbers</title><link>https://mohkale.gitlab.io/brain/20210627011344-fibonacci_numbers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627011344-fibonacci_numbers/</guid><description>Is a sequence of numbers defined inductively as:
\begin{align} f_0 &amp;amp;= 0 \
f_1 &amp;amp;= 1 \
f_n = f_{n-1} + f_{n-2}, \qquad n &amp;gt; 1 \end{align}</description></item><item><title>File</title><link>https://mohkale.gitlab.io/brain/20211010184224-file/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010184224-file/</guid><description>Is an entry in a file-system that can contain some data.
You can create a file using the open system-call, and retrieve a file-descriptor id. You can then read, write, or otherwise interact with the file before finally closing it.
Non-Blocking File IO Calls to read() or write() for a file-descriptor are blocking by default. This means the active thread waits until the data to be read is available and the data to be written has all been written before continuing.</description></item><item><title>File Carving</title><link>https://mohkale.gitlab.io/brain/20210415003857-file_carving/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415003857-file_carving/</guid><description>An [see page 6, approach] for extracting data from a storage device without the assistance of the file-system. Consider being given a file-system as just a massive BLOB with no known file-system info. We can look for file signatures to find file information, even without knowledge of how the file-system is structured.
This approach is effective at recovering files in unallocated space (such as the deleted files space) where file-information doesn't exist.</description></item><item><title>File Description</title><link>https://mohkale.gitlab.io/brain/20211002203448-file_description/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002203448-file_description/</guid><description>Is the underlying struct pointed to by a file descriptor and contains metadata related to the underlying file.
The file description maintains the path to the file, how far into the file had been read, etc. etc.</description></item><item><title>File Descriptor</title><link>https://mohkale.gitlab.io/brain/20211002203333-file_descriptor/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002203333-file_descriptor/</guid><description>Is a handle (integer) pointing to a file description that is held by a process and maintained by the kernel. A file descriptor can point to many different structs or you could have multiple descriptors pointing the same struct.</description></item><item><title>File Signatures</title><link>https://mohkale.gitlab.io/brain/20210415003456-file_signatures/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415003456-file_signatures/</guid><description>A [see page 5, file signature] is a unique sequence of identifying bytes written to a files header (I.E. the magic value sometimes used to determine the mime-type).
For example a JPEG image has a file header of FFD8 whereas PNG has 89504e47.
We use both file-headers and footers to determine file types.</description></item><item><title>File System</title><link>https://mohkale.gitlab.io/brain/20210415003256-file_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415003256-file_system/</guid><description>A data format used to map information stored in disk partitions to files and hierarchies of files (directories) scattered across the disk.
When looking up a file in the file-system the OS recursively looks up i-nodes from the first directory entry in the path until it reaches the file.
Table 1: Listing of some common see page 4, [file systems]. Name Full Name FAT File allocation table HFS Hirearchal file system NTFS New technology file system EXT4 Extended journaling file system procfs Process information pseudo file system sysfs System file system tmpfs Temporary file system Note: Some file systems don't provide interfaces to things that are files.</description></item><item><title>Filter</title><link>https://mohkale.gitlab.io/brain/20201102162320-filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102162320-filter/</guid><description>[see page 14, Modifies] the properties of a signal.
A filter can be [see page 1, defined] as \[ y[k] = x[k] \times h[k] \] where \(x[k]\) is the value of the input signal at time \(k\), and \(h[k]\) is the filter transformation. \(y[k]\) is the signal outputted by the filter.
Typically characterised by it's [see page 14, frequency-response] in the frequency-domain:
FR Meaning Low Pass Allow only low frequencies through.</description></item><item><title>Filter Approximation</title><link>https://mohkale.gitlab.io/brain/20201120235414-filter_approximation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120235414-filter_approximation/</guid><description>Filters are often [see page 1, described] as in idealised forms, however practical filters only approximate these forms.
In practice (both [see page 2, lowpass] and bandpass) filters we find:
ripples (fluctuations in amplitude) where we expect continuous regions. slopes (curved declines) where we expect linear drops in gain.</description></item><item><title>Filter Coefficients</title><link>https://mohkale.gitlab.io/brain/20210201042223-filter_coefficients/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210201042223-filter_coefficients/</guid><description>Refers to the number of past inputs or outputs involved in a filter calculation.</description></item><item><title>Filter Model of Speech</title><link>https://mohkale.gitlab.io/brain/20210130015607-filter_model_of_speech/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130015607-filter_model_of_speech/</guid><description>A [see page 17, model] of speech which emulates human speech using source-filter-modelling.
Essentially we have a sound source that we direct into a parameterised vocal-tract filter. The parameters of the filter emulate how the actual vocal tract articulators change to produce different noises. The sound source will be a impulse generator for voiced speech or a noise-source for unvoiced speech.
This model essentially emulates the human speech apparatus mathematically.</description></item><item><title>Filter Order</title><link>https://mohkale.gitlab.io/brain/20210131050856-filter_order/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131050856-filter_order/</guid><description>Refers to the [see page 3, number] of coefficients (past inputs or outputs (not both)) of the filter that is involved in the current calculation.
Filter complexity is often characterised by it's order.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } The degree to which a practical filter [approximates](/brain/20201120235414-filter_approximation/) it's idealised form is a function of its order. Note: We consider any filter that uses the current input as a first-order filter.</description></item><item><title>Financial Statements</title><link>https://mohkale.gitlab.io/brain/20201011234241-financial_statements/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201011234241-financial_statements/</guid><description>Summary of Financial Accounting.
See characteristics of a [see page 10, financial statement], to summarise financial information should be:
Relevant Predictive value, can be used to form expectations about the future Confirmatory value, can confirm or correct prior expectations Materially complete. Information is material if omitting (or mistating) it could change the decisions made by users. Faithfully Representative Complete, all relevent information is provided Neutral, information cannot favor one interested party over another Free from error It would also be nice if the account is:</description></item><item><title>Fingerprint Authentication</title><link>https://mohkale.gitlab.io/brain/20210212003108-fingerprint_authentication/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210212003108-fingerprint_authentication/</guid><description>A form of biometric authentication that uses a persons fingerprint imprint to uniquely identify them.
This approach suffers from [see page 2, various] issues, including:
Enrolment - Purchase (acquire) fingerprints from someone else Compromise the reader Compromise the communications from the reader to the server Compromise the central database (storing recorded fingerprints) Breath on (or cover with powder) the sensor plate to reveal recorded fingerprints Create a dummy finger :?</description></item><item><title>Finite Context Model</title><link>https://mohkale.gitlab.io/brain/20201102010815-finite_context_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102010815-finite_context_model/</guid><description>A text-compression model which takes into account the surrounding context.</description></item><item><title>Finite Impulse Response Filter</title><link>https://mohkale.gitlab.io/brain/20201121012537-finite_impulse_response_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201121012537-finite_impulse_response_filter/</guid><description>A filter with 0 poles. For any finite input you receive a finite output. See [see page 5, here].
FIR filters are defined as a weighted sum of the last N inputs, because poles are defined by previous outputs and if there're no poles then no previous outputs are used.
See [see page 5, here] for advantages/disadvantages. Highlights:
These filters are stable (they eventually decay to zero). Generally require more coefficients (outputs of previous filterings).</description></item><item><title>Firmware</title><link>https://mohkale.gitlab.io/brain/20210811035527-firmware/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811035527-firmware/</guid><description>Is a specific class of computer software providing low level control for a devices hardware.
Firmware is generally embedded onto read-only memory in computer chips such as ROM.</description></item><item><title>First-Come-First-Served Scheduler</title><link>https://mohkale.gitlab.io/brain/20211009142234-first_come_first_served_scheduler/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009142234-first_come_first_served_scheduler/</guid><description>Is a scheduling algorithm where processes are schedule in the order of arrival.
In this case the ready-queue is a simple FIFO stack.
Advantages Disadvantages Simple algorithm and implementation The convoy effect Context switches infrequent for long running processes No starvation if all processes are guaranteed to terminate</description></item><item><title>Flashlight</title><link>https://mohkale.gitlab.io/brain/20201108172616-flashlight/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201108172616-flashlight/</guid><description>A flashlight is a spotlight located at the viewer's position and usually aimed straight ahead from the player's perspective. A flashlight is basically a normal spotlight, but with its position and direction continually updated based on the player's position and orientation.</description></item><item><title>Flat Shading</title><link>https://mohkale.gitlab.io/brain/20201023203044-flat_shading/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023203044-flat_shading/</guid><description>A simple way of shading in which we simply assign a constant pixel value to each polygon. Different polygons can have different colors, but the color of a pixel in the same polygon is constant.</description></item><item><title>Flaws vs. Vulnerabilities</title><link>https://mohkale.gitlab.io/brain/20210430004041-flaws_vs_vulnerabilities/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430004041-flaws_vs_vulnerabilities/</guid><description>Both relate to security threats. Flaws are things that are wrong or could be better. Vulnerabilities are flaws that can be exploited by an attacker.
This means vulnerabilities are flaws that are be accessible (attacker must be able to get at them) and exploitable (hacker must be able to get some damage with it).
For [see page 32, example] disabling bluetooth can turn a vulnerability into a flaw.</description></item><item><title>Floating Point</title><link>https://mohkale.gitlab.io/brain/20210718011954-floating_point/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718011954-floating_point/</guid><description>Is a notation for storing rational numbers.
In general the encoding of the number is split into a mantissa and a exponent. To store \( 1.234 \times 10^{23} \) we'd have a mantissa \( 1.234 \) and an exponent of \( 23 \).</description></item><item><title>Floor</title><link>https://mohkale.gitlab.io/brain/20210627055734-floor/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627055734-floor/</guid><description>Is an algorithm to truncate the non-integer part of an rational number. Mathematically we represent flooring a number \( i \) as \( \lfloor i \rfloor \).</description></item><item><title>Flow Chart</title><link>https://mohkale.gitlab.io/brain/20210622171026-flow_chart/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622171026-flow_chart/</guid><description>A special graph used to represent an algorithm.
Element Shape Example Text Instruction \text{\tikz \draw (0,0) rectangle (2, 1);} Print B Decision (yes/no) \text{\tikz [rotate=45] \draw (0,0) rectangle (1,1);} if \( x &amp;lt; 5 \) Start/Finish \text{\tikz \drawrounded corners rectangle (2,1);} Start For example you can visualise Euclid's algorithm as a flow chart in fig:euclid-flow.
\begin{figure} \centering \begin{tikzpicture} \node (start) [draw, rectangle] {Start}; \node (input) [draw, rectangle, below=of start] {Input \(a, b \qquada \geqb \)} edge [&amp;lt;-] (start); \node (letp) [draw, rectangle, below=of input] {Let $P$ = Integer part of \(\frac{a}{b} \)} edge [&amp;lt;-] (input); \node (letq) [draw, rectangle, below=of letp] {Let \(q =Pb \)} edge [&amp;lt;-] (letp); \node (letr) [draw, rectangle, below=of letq] {Let \(r =a -q \)} edge [&amp;lt;-] (letq); \node (ris0) [draw, diamond, below=of letr] {Does \(r =0\)?</description></item><item><title>Foreign Key</title><link>https://mohkale.gitlab.io/brain/20210815020642-foreign_key/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815020642-foreign_key/</guid><description>Is a special [see page 6, column] in a relational database table that points to a primary key in another table.</description></item><item><title>Forensic Tools</title><link>https://mohkale.gitlab.io/brain/20210313201238-forensic_tools/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210313201238-forensic_tools/</guid><description>Refers to various tools used in the digital forensic process.
FTK Imager [see page 2, Used] to create disk or memory images.
Forensic Toolkit (FTK) Used for analysis of data copied using FTK Imager.
Autopsy Used as a [see page 5, platform] which is extended third party plugins to give analysts powerful tools for investigating various incidents.
Is FOSS.
Volatility Command line [see page 7, utility] used for memory forensics. Can find out processes running on a particular computer, what applications where running, what sockets were open, communications with the computer (including IP)</description></item><item><title>Fork</title><link>https://mohkale.gitlab.io/brain/20211002192012-fork/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002192012-fork/</guid><description>Is a system-call that clones the current process to create a new-process, duplicating the state of the existing process with a few minor differences. See fork.
Both the child and current process executes the line after the fork, just like the parent. The return value of fork is -1 if it failed, 0 when in the child process and the PID of the child-process when in the parent. The child can later access its parents PID using getppid, however the only way for a parent to know its child's PID is to store the output of fork.</description></item><item><title>Fork Bomb</title><link>https://mohkale.gitlab.io/brain/20211002193406-fork_bomb/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002193406-fork_bomb/</guid><description>Is a resource attack that overloads a computers resources by spawning an exponential number of processes in a short amount of time through recursive forking.
The general structure of a fork bomb involves defining a process that spawns itself at least twice and doesn't have any way to terminate. It'll keep doubling up until you run out of system resources.
Examples while (1) fork(); Code Snippet 1: A C fork-bomb. fork() { fork|fork &amp;amp; } fork Code Snippet 2: A shell script fork bomb.</description></item><item><title>Fork-Exec-Wait Pattern</title><link>https://mohkale.gitlab.io/brain/20211002214643-fork_exec_wait_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002214643-fork_exec_wait_pattern/</guid><description>Is a common programming pattern where a process calls fork followed by exec in the child-process and wait in the parent-process. This pattern allows the parent to monitor and control the execution of the child process.</description></item><item><title>Formal Systems Development</title><link>https://mohkale.gitlab.io/brain/20210629020440-formal_systems_development/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210629020440-formal_systems_development/</guid><description>Is a software design model that uses a formal [see page 15, specification] of the original requirements (in a mathematical specification language such as OCL) to prove the safety and correctness of the software implementation.
This approach is generally used for safety critical systems such as microprocessor design, routers, switches, hypervisors, security applications etc. However it requires mathematical expertise, and is rarely applicable for most software projects that value time to market over correctness.</description></item><item><title>Formant</title><link>https://mohkale.gitlab.io/brain/20201020215235-formant/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020215235-formant/</guid><description>A resonance of the vocal tract. Each peak in the speech-spectrum is a formant.</description></item><item><title>Fountain Lifecycle</title><link>https://mohkale.gitlab.io/brain/20210629021748-fountain_lifecycle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210629021748-fountain_lifecycle/</guid><description>Is a SDLC where we develop and deliver one task at a time, maintaining a working prototype system at each increment. When errors are detected or changes are requested you revisit earlier tasks and fix them.
This can be visualised as a [see page 19, fountain] where each task gushes forward, but some may fall-back to be caught and recycled later.</description></item><item><title>Fourier Series</title><link>https://mohkale.gitlab.io/brain/20201102153638-fourier_series/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102153638-fourier_series/</guid><description>The series of sinusoids used in a fourier decomposition (transformation).
This series is generally unique to the signal being transformed. We define:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } \\(f\_0\\) as the fundamental frequency. \\(f\_1, f\_2, ... f\_n\\) as the harmonics of this frequency. It's also worth noting that each sinusoid in the series can be characterised by it's:
Frequency Amplitude Phase</description></item><item><title>Fourier Theorem</title><link>https://mohkale.gitlab.io/brain/20201102152406-fourier_theorem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102152406-fourier_theorem/</guid><description>Is an extension of the idea of the Frequency Domain, whereby any periodic signal of frequency \(f_0\) can be [see page 2, constructed] exactly by adding together sinusoids in the Fourier Series.</description></item><item><title>Fourier Transform</title><link>https://mohkale.gitlab.io/brain/20201102161948-fourier_transform/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102161948-fourier_transform/</guid><description>Is the quintessential frequency-analysis function which can map continuous time-domain input into frequency-domain within the fourier-series at \(N\) evenly spaced discrete frequencies.
Note: This transformation is [see page 13, lossless]. Note: You can find an intuitive description of fourier, here.
There're several [see page 17, variants] of the general FT algorithm:
Variant Description Fourier Transform Continuous time signals to continuous frequency domain. Discrete Fourier Transform Transform discrete time signals to the discrete frequency domain.</description></item><item><title>Fragments</title><link>https://mohkale.gitlab.io/brain/20201107021905-fragments/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201107021905-fragments/</guid><description>The output of the rasterisation shader which represents individual pixels on an objects surface that can be given a distinct color.</description></item><item><title>Frame</title><link>https://mohkale.gitlab.io/brain/20210911025701-frame/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911025701-frame/</guid><description>Is a [see page 6, wrapper] used to specify the body of a model relates to a specific class or entity. Any model can be [see page 8, placed in a frame] since UML 2.0.
This can be done in tikz-uml using the package environment.</description></item><item><title>Frame</title><link>https://mohkale.gitlab.io/brain/20211008234243-frame/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008234243-frame/</guid><description>Is a contiguous block of physical memory (such as RAM), much akin to a page.
Note: frames can be shared between processes. If the page-table marks a frame as read-only then it can shared between processes. This is useful for example in the C library instruction code in all processes that dynamically load it into their memory.</description></item><item><title>Frequency</title><link>https://mohkale.gitlab.io/brain/20210128050103-frequency/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128050103-frequency/</guid><description>The number of [see page 9, complete] cycle per second in a wave.
Energy/Power The amount of energy needed to penetrate the [see page 7, threshold-of-hearing] varies depending on the frequency.</description></item><item><title>Frequency Analysis</title><link>https://mohkale.gitlab.io/brain/20201102151639-frequency_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102151639-frequency_analysis/</guid><description>The process of decomposing a discrete (or continuous) signal into periodic functions in the Frequency Domain.
This is [see page 7, guaranteed] to exist for any periodic (repeating) signal (through fourier theorem) and can be found for any non-periodic signal through the fourier series.
Fourier Analysis The [see page 6, graphing] of a signal in an amplitude-time graph and a amplitude-frequency graph.
See the fourier analysis of:
[see page 2, sinus] cosinus sawtooth square triangular</description></item><item><title>Frequency Domain</title><link>https://mohkale.gitlab.io/brain/20201115234229-frequency_domain/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201115234229-frequency_domain/</guid><description>A possible representation of a time-domain signal which rather than showing how a signals amplitude changes overtime, shows how much of the signal is present among each given frequency band.
See here and this.
Think of sound as a combination of multiple frequencies combining at each point in time to give the sound its amplitude. Frequency domain graphs extract and partition these frequencies and their associated amplitudes into a different form.</description></item><item><title>Frequency-Analysis Attack</title><link>https://mohkale.gitlab.io/brain/20210215023418-frequency_analysis_attack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215023418-frequency_analysis_attack/</guid><description>A form of [see page 11, attack] on substitution ciphers which tries to exploit the frequency of certain characters in the ciphertext to reveal information about the plaintext. For example the most common character in English words is e so if the character that occurs the most in the ciphertext is an z then it's highly likely that an input of z can be decrypted to a plaintext e.
More complex applications of frequency-analysis use the most-common Bigrams (two letter sequences) or (Trigrams) three letter sequences to help you guess the correspondences between the plaintext to ciphertext mappings.</description></item><item><title>FTP</title><link>https://mohkale.gitlab.io/brain/20211009184128-ftp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009184128-ftp/</guid><description>An application layer protocol for transferring a file from one computer to another.</description></item><item><title>Function</title><link>https://mohkale.gitlab.io/brain/20210621185639-function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621185639-function/</guid><description>In maths a function is a concept mapping from a domain of possible inputs into a range of possible outputs, where the function must consistently give the same outputs for the same inputs. That is to say a function cannot output 5 for input 6 and then 7 for the same input if called again.
We can [see page 12, denote] a function mapping from the domain \( A \) to the range \( B \) as \( f : A \rightarrow B \)</description></item><item><title>Function Composition</title><link>https://mohkale.gitlab.io/brain/20210627010935-function_composition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010935-function_composition/</guid><description>Is the process of [see page 16, combining] or chaining one function with another. This is commonly expressed using the \( \circ \) notation, for example \( f \circ g (x) = f(g(x)) \).
Note: Function composition happens right first, not left first.
Self Composition Is the process of composing a function with itself.
More generally we define \( f \circ f \) as \( f^2 \) and \( f \circ f^n \) as \( f^{n+1} \).</description></item><item><title>Function Graph</title><link>https://mohkale.gitlab.io/brain/20210627010220-function_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010220-function_graph/</guid><description>Is [see page 14, defined] as the set of tuples of the input-output pairs of a function. \[ \text{graph}(f) = \{ (a, b) \in A \times B : b = f(a) \} \]</description></item><item><title>Function Image</title><link>https://mohkale.gitlab.io/brain/20210627010610-function_image/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010610-function_image/</guid><description>Is [see page 22, defined] as the range for a subset of a functions domain. I.E. for a function \( f : A \rightarrow B \) and a set \( S \subseteq A \) the image of the function is \( \{ f(a) : a \in S \} \).</description></item><item><title>Function Points</title><link>https://mohkale.gitlab.io/brain/20210626234436-function_points/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234436-function_points/</guid><description>An analysis metric used to [see page 9, measure] the functionality delivered by a system from the point of view of the user.
Function points [see page 10, define] the following components:
Input: data entering the system. Output: data leaving the system. Inquiries: data queries. Files: Data manufactured and stored within the system. Interface: Data maintained in a different system. These are then [see page 13, combined] together to get a quantitative measure of system functionality.</description></item><item><title>Function Pre-Image</title><link>https://mohkale.gitlab.io/brain/20210627010732-function_pre_image/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010732-function_pre_image/</guid><description>Is [see page 22, defined] as the domain for a subset of a functions range. I.E. for a function \( f : A \rightarrow B \) and a set \( T \subseteq B \) the pre-image of the function is \( \{ a \in A : f(a) \in T \} \).</description></item><item><title>Function Representation</title><link>https://mohkale.gitlab.io/brain/20201016215858-function-representation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201016215858-function-representation/</guid><description>A 3D representation based on mathematical [see page 8, functions]. For example we can represent a circle (or [see page 9, sphere]) using an equation.
Functions in this model can be represented as either:
Form Description Implicit Represents the idea of a shape (eg. \(F(x,y) = x^2 + y^2 - r^2 = 0\)) Parametric Each axis position is defined in terms of some parameter \(t\) With the implicit form we can't find \((x,y)\) because there's an infinite number of possible values, but we can quickly detect whether a point is within the area of the circle.</description></item><item><title>Functions as Relations</title><link>https://mohkale.gitlab.io/brain/20210627012015-functions_as_relations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627012015-functions_as_relations/</guid><description>For a function \( f : A \rightarrow B \) there [see page 16, must] be a relation \( R \subseteq A \times B \) that satisfies \( \forall a \in A \exists ! b \in B ((a, b) \in R) \). We define this special function as \( f_R : A \rightarrow B \).</description></item><item><title>Fundamental Frequency</title><link>https://mohkale.gitlab.io/brain/20201115215251-fundamental_frequency/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201115215251-fundamental_frequency/</guid><description>The first-harmonic or lowest-frequency a particular instrument can produce.</description></item><item><title>Fundamental Theorem of Arithmetic</title><link>https://mohkale.gitlab.io/brain/20210831004114-fundamental_theorem_of_arithmetic/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210831004114-fundamental_theorem_of_arithmetic/</guid><description>Is Euclid's theory relating to the decomposition of a composite number into the product of a finite series of primes. It states that every integer greater than 1 can be represented uniquely as a product of the prime numbers up to the order of the factors.
Every possible number has one, and only one, prime factorisation.
For example 1200 has prime-factors (factors that are prime) of 2, 3, and 5.</description></item><item><title>FURPS</title><link>https://mohkale.gitlab.io/brain/20210626233237-furps/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626233237-furps/</guid><description>Is a an [see page 13, anagram] used to help outline the requirements of a software project:
Functionality: What the application should do? Usability: What the program should look like? Reliability: How reliable the system should be (see availability)? Performance: How efficient the system should be? Supportability: How easy is it to support the application.</description></item><item><title>Fuzzing</title><link>https://mohkale.gitlab.io/brain/20210607001058-fuzzing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607001058-fuzzing/</guid><description>Is a highly effective, largely automated, security testing [see page 36, technique] that generates random inputs and sees if an application crashes.
Originally fuzzing generated very long inputs and checks if a segfault is triggered (due to buffer overflow), however it's been extended to the domain of automated input generation and result assertion.
TODO: See [see page 38, ideas], [see page 39, pros &amp;amp; cons], [see page 40, fuzzing tools].</description></item><item><title>Gearing</title><link>https://mohkale.gitlab.io/brain/20201021183531-gearing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021183531-gearing/</guid><description>Financial gearing (leverage) looks at how the company is financed.
If a business has a high level of non-current liabilities (debt) there is a potential risk that in the medium-long term these loans cannot be repaid and the business will fail (financial fisk). See [see page 20, here] for a practical example of the impact of gearing.
Gearing (Debt to Equity) Ratio \[ Debt/Equity = \frac{Loans + Overdrafts}{Share Capital + Reserves} \]</description></item><item><title>Geffe Generator</title><link>https://mohkale.gitlab.io/brain/20210215042033-geffe_generator/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215042033-geffe_generator/</guid><description>A stream cipher which [see page 26, multiplexes] 3 other input stream.
The Geffe generator uses:
Term Description \( j \) The current bit index in the output stream \( d_j \) \(\text{LSFR}_1\) The selector-stream \( e_j \) \(\text{LSFR}_2\) \( f_j \) \(\text{LSFR}_3\) \( b_j = (d_j \land e_j) \xor ((\neg d_j) \and f_j) \) The gaffe generator has the following [see page 27, properties]:</description></item><item><title>General Adversarial Network</title><link>https://mohkale.gitlab.io/brain/20210208044326-general_adversarial_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210208044326-general_adversarial_network/</guid><description>Is a form of semi-supervised learning, using two depp-learning networks in competition with each other.
One network tries to create new data points that mimic the training data and the other evaluates whether they are part of the training data or fakes. These two networks operate in a positive feedback loop, ~as the discriminator gets better at separating fakes from the originals, the generator improves its ability to create convincing fakes~.</description></item><item><title>General Digital Filter</title><link>https://mohkale.gitlab.io/brain/20210131043901-general_digital_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131043901-general_digital_filter/</guid><description>Refers to a filter defined in terms of the [see page 4, general-difference-equation]. Such practical filters are defined in some order based on the degree to which the filter approximates it's idealised form.
The general difference equation is defined as: \[ Y(Z) = Y(z) \sum_^{p}{a_i {z}^{-i}} + X(z) \sum_^{q}{b_i {z}^{-i}} \] With:
Variable Meaning \( p, q \) Number of poles and zeros respectively \( a_i \) The output of the filter at time \( i \) \( b_i \) The input to the filter at time \( i \) Which can be re-arranged into a form matching the z-plane transfer function.</description></item><item><title>Geometric Series</title><link>https://mohkale.gitlab.io/brain/20210621183731-geometric_series/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621183731-geometric_series/</guid><description>A number series where the value of the next entry is equal to the current entry multiplied by some constant \( r \).
For such a series we can use the following formulae to find the \(n^{\text{nth}}\) element, the sum from the first to the \(n^{\text{nth}}\) element and the sum to infinity (what the sum of the series tends to as \( n \) approaches infinity).
\begin{align} u_n &amp;amp;= ar^{n--1} \</description></item><item><title>Geometric Shadows</title><link>https://mohkale.gitlab.io/brain/20201027185842-geometric_shadows/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027185842-geometric_shadows/</guid><description>Approaches to produce a shadow which calculate the shape of a shadow but only guesses at its reflected light intensity.
This takes advantage of a few observations of a scene.
Shadows are hidden from light sources. A point light source means no penumbra. Shadows do not change in a static scene.</description></item><item><title>Gimbal Lock</title><link>https://mohkale.gitlab.io/brain/20201107195138-gimbal_lock/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201107195138-gimbal_lock/</guid><description>Refers to the phenomenon where one degree of freedom is lost when two euler-angles are parallel to each other.
Each euler angle corresponds to one degree of freedom and contributes to an objects positioning for that angle. If two are parallel than the object loses the ability to rotate across the missing degree of freedom.</description></item><item><title>Global Illumination</title><link>https://mohkale.gitlab.io/brain/20210106020546-global_illumination/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106020546-global_illumination/</guid><description>Is the [see page 11, problem] of accurately and realistically rendering the lighting of a scene. Both phong-illumination and ray-tracing are attempts to approximate this.
This can be accurately canted as the rendering-equation (Warn: this equation doesn't cover all aspects of lighting) which consists of:
Term Description Emmited spectral radiance BRDF Inward spectral radiance Lambert The essential idea is for each point x we want to find the incidence and intensities of all rays leading to that point (multiplied by some reflectance property).</description></item><item><title>Golang</title><link>https://mohkale.gitlab.io/brain/20210726054214-golang/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210726054214-golang/</guid><description>Go is a relatively new language from the venerated Rob Pike and other legends from the age of bell labs and early Unix. It values consistency and explicitness at the cost of verbosity and an unconventional approach to building highly concurrent applications.
Syntax Comments The go language supports both c style inline and multi-line comments.
// Here&amp;#39;s an inline comment /* Here&amp;#39;s a multiline comment */ Modules A module is a collection of packages.</description></item><item><title>Gouraud Interpolative Shading</title><link>https://mohkale.gitlab.io/brain/20201023205406-gouraud_interpolative_shading/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023205406-gouraud_interpolative_shading/</guid><description>A way of shading in which we [see page 27, bilinearly interpolate] vertex intensities over the polygon to determine the intensity at each pixel.
What this means is that we calculate the color intensity at each vertex of the polygon and then interpolate between these colors for each pixels in the polygon. This process calculates intensities only at vertices, meaning it has [see page 30, difficulty] with specular highlights when the number of polygons is few.</description></item><item><title>Government Securities</title><link>https://mohkale.gitlab.io/brain/20210110030926-government_securities/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110030926-government_securities/</guid><description>Bonds issued by companies or governments to raise money. Investors purchase bonds at the face value and later get a return at a fixed interest (coupon) rate. Each bond has a maturity date indicating when the investor gets payed back the face value of the bond.
A negative bond yield is when an investor receives less money on return than they spent for the bond. This can be due to for eg.</description></item><item><title>Gradable Lexicon</title><link>https://mohkale.gitlab.io/brain/20201117013808-gradable_lexicon/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201117013808-gradable_lexicon/</guid><description>A lexicon based [see page 16, approach] to sentiment analysis. It uses grade adverbs to amplify or weaken an emotion word.
For the gradable approach the lexicon can have a range of possible values for each word. They can range from some upper maximum and some lower minimum. This approach also applies a few rules to account for intensifiers.
Rules work like function transformations. When a rule is evaluated its transformation is applied to the orientation of the rest of the words around it.</description></item><item><title>Gradient Algorithm</title><link>https://mohkale.gitlab.io/brain/20210131235135-gradient_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131235135-gradient_algorithm/</guid><description>Is an algorithm for gradient-descent.
See [see page 23, comparison] of different algorithms for finding the minimum error.</description></item><item><title>Gradient Descent</title><link>https://mohkale.gitlab.io/brain/20210107212728-gradient_descent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210107212728-gradient_descent/</guid><description>An algorithm to find the parameters which cause an equation/curve to output the minimum point. Essentially we [see page 13, pick] a point and then keep travelling along the curve in the negative gradient direction by a given step size until we can't get any lower.
Gradient descent uses the gradient to tell how the error will change given a change in parameters. The curve plots the error on the Y-axis and the current parameter on the X-axis.</description></item><item><title>Gram-Schmidt Process</title><link>https://mohkale.gitlab.io/brain/20201106225026-gram_schmidt_process/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106225026-gram_schmidt_process/</guid><description>A way for calculating the coordinate axes \((N,U,V)\) for cameras view coordinate system.
We define \(N\) arbitrarily based on some point in the world-coordinate system we want to look at.
For the remaining axes \(U,V\) we [see page 8, try] to define \(U\) such that it's close to Y. So we:
Guess a \(U\), \(U'\), and use that to find \(V\) such that \(V\) is perpendicular to \(N\). Find a \(U\) that's perpendicular to \(V\) and \(N\).</description></item><item><title>Grandmother Cell</title><link>https://mohkale.gitlab.io/brain/20210301035858-grandmother_cell/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210301035858-grandmother_cell/</guid><description>A [see page 9, hypothetical] neuron that responds only to a highly complex, specific and meaningful stimulus such as the image of ones grandmother.
This generally wouldn't be a good thing... because such a cell wouldn't be useful for identifying anything other than your grandmother, but because we're using a hierarchy of multiple cells contributing to the grandmother cells effectiveness, we can adapt to recognise other stimuli similar to the grandmother.</description></item><item><title>Graph</title><link>https://mohkale.gitlab.io/brain/20210622172313-graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622172313-graph/</guid><description>A graph \( G \) consists of points/vertices/nodes which are connected by lines/edges/arcs.
The Handshaking Theorem States that the sum of the valencies of each vertex of a graph is twice the number of edges in the graph: \[ \sum_{v \in \text{odd}} |v| + \sum_{v \in \text{even}} |v| = 2 \times E(G) \]</description></item><item><title>Graph Transformations</title><link>https://mohkale.gitlab.io/brain/20210621230813-graph_transformations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621230813-graph_transformations/</guid><description>Largely divided into 4 transformations:
Translation Enlargement \(\longrightarrow\) Stretching Reflection Rotation If we define a graph \( y = f(x) \), then
\( y = -f(x) \) creates a reflection of the graph on the y-axis. \( y = f(-x) \) creates a reflection of the graph on the x-axis. \( y = f(x+z) \) pushes the graph by \( -z \) on the x-axis. \( y = f(x)+z \) pushes the graph by \( z \) on the y-axis.</description></item><item><title>Graphics Pipeline</title><link>https://mohkale.gitlab.io/brain/20200929004429-graphics_pipeline/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200929004429-graphics_pipeline/</guid><description>The high level [see page 25, Stages] in rendering something. Involves a mapping points through a [see page 2, bunch] of coordinate spaces until we get a 2D projection on the display space.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } the entire process vertices have to walk through before ending up as one or more pixels on the screen. A basic graphics system goes from the CPU, to the Graphics Processor to the Frame Buffer, before finally rendering the result back to the users screen.</description></item><item><title>Greatest Common Divisor</title><link>https://mohkale.gitlab.io/brain/20210830223856-greatest_common_divisor/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830223856-greatest_common_divisor/</guid><description>Is a concept describing the largest factor shared by two non-zero numbers \( x, y \), written as \( \gcd (x, y) \).
Table 1: Listing of the unique divisors of both 8 and 12. \label{tbl:gcd-8-12-eg} Number Factor Pairs Unique Divisors 8 \( 8 \times 1 \), \( 4 \times 2 \) 1, 2, 4, 8 12 \( 12 \times 1 \), \( 6 \times 2 \), \( 3 \times 4 \) 1, 2, 3, 4, 6, 8 For example consider \( \gcd (8, 12) \).</description></item><item><title>Greedy Algorithms</title><link>https://mohkale.gitlab.io/brain/20210628054931-greedy_algorithms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054931-greedy_algorithms/</guid><description>Are algorithms which make greedy, locally optimal, choices for sub-problems in the hopes that this yields a globally optimal solution.
The greedy choice is generally a [see page 10, good choice] if:
Cast the optimisation problem as one in which we make a choice and are left with one sub-problem to solve. Prove that there is always an optimal solution to the original problem that makes the greedy choice, so that the greedy choice is always safe.</description></item><item><title>Greedy Reward Policy</title><link>https://mohkale.gitlab.io/brain/20210415001218-greedy_reward_policy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415001218-greedy_reward_policy/</guid><description>A reward policy which always [see page 10, chooses] the action that has the maximum Q-value: \[ Q(s, a_i) &amp;gt; Q(s, a_j) \forall j != i \]
But this conflicts when we [see page 11, don't know] our Q-values:
...but Q-values depend on the probability (and reward) of taking an action ...but if we choose our actions based on our policy, our policy can't rely on knowing the \( Q \) values beforehand.</description></item><item><title>GTest</title><link>https://mohkale.gitlab.io/brain/20220124142847-gtest/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220124142847-gtest/</guid><description>Is the standard testing framework for CPP provided by Google.
Tests #include &amp;lt;gmock/gmock.h&amp;gt;#include &amp;lt;gtest/gtest.h&amp;gt; using namespace ::testing; template &amp;lt;class T&amp;gt; T square(T i) { return i * i; } // You declare a test case with the TEST macro. // // The first argument is the namespace/scope of the test case // and the second argument is the test name. TEST(Square, testThatRegularInputGivesCorrectAnswer) { // You can stream values into assertions to provide more debug output.</description></item><item><title>GUID Partition Table</title><link>https://mohkale.gitlab.io/brain/20210813233929-guid_partition_table/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210813233929-guid_partition_table/</guid><description>Is an alternative partition record scheme to MBR supporting more partitions and partition sizes larger than 2 TiB. It also uses LBA.
GPT uses 64 bits for logical block addresses, allowing a maximum disk size of \( 2^{64} \)-sectors. For disks with 512-byte sectors the maximum size is 8 ZiB.
Protective MBR In the interest of backward compatibility the space of the legacy MBR is still reserved in the GPT specification, however now it's only used to prevent MBR based utilities from recognising or possibly overwriting GPT disks.</description></item><item><title>Hamming Window</title><link>https://mohkale.gitlab.io/brain/20201110190314-hamming_window/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110190314-hamming_window/</guid><description>A windowing-function proposed by [see page 13, Richard W. Hamming].
It is visually identical to the von-hann-window in the time domain however it is noticeably [see page 14, different] in the frequency-domain. In the frequency domain there's noticeably less leakage into other frequencies.
\[ w_{Hm}[nT] =0.54 - 0.46 . cos(\frac{2.\pi.n}{N-1}) \]</description></item><item><title>Hands Free System</title><link>https://mohkale.gitlab.io/brain/20201127210807-hands_free_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127210807-hands_free_system/</guid><description>Describes a [see page 2, system] where two people speak to each other through some audio-system (eg. phone).
Consists of:
dereverberation acoustic-echo-cancelation Noise Reduction</description></item><item><title>Happy Flow</title><link>https://mohkale.gitlab.io/brain/20210607024206-happy_flow/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607024206-happy_flow/</guid><description>The right/wanted behaviour for sensible inputs in a software system.</description></item><item><title>Hard Disk</title><link>https://mohkale.gitlab.io/brain/20211010162134-hard_disk/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010162134-hard_disk/</guid><description>Is a piece of hardware that can be used for disk memory.
The surface area of a hard-disk is a disk divided into circular tracks which are then pie sliced into sectors (disk blocks). Tracks near the outer edge of the disk have more area than those closer to the spindle at the disk centre, so more slices are placed in them. Each sector generally has the same size (in Unix 1KB) and a unique address (disk block number).</description></item><item><title>Hard Link</title><link>https://mohkale.gitlab.io/brain/20211010190629-hard_link/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010190629-hard_link/</guid><description>Is a directory entry that points to an inode that's already pointed to by another directory entry. Essentially a hard-link allows multiple file-names in the file system to direct to the same data stored on a disk.
You can create a hard-link using the link system-call. A hard-link can be created anywhere in the file-system however you can't create directory hard-links, only files.
The integrity of the file system assumes the directory structure is an acyclic tree that is reachable from the root directory.</description></item><item><title>Hardware Interrupt</title><link>https://mohkale.gitlab.io/brain/20210930020304-hardware_interrupt/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210930020304-hardware_interrupt/</guid><description>Is a hardware level interrupt, passed as an electrical signal to the CPU when something happens (example: key-press).</description></item><item><title>Harmonic Trig Form</title><link>https://mohkale.gitlab.io/brain/20210621201542-harmonic_trig_form/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621201542-harmonic_trig_form/</guid><description>Is a way to express an equation in terms of \( \sin x \) and \( \cos x \) as a scaled value of an offset cosine or sine. That is to say solving \( a \cos x + b \sin x = R \cos (x \pm \alpha) \) or \( a \cos x + b \sin x = R \sin (x \pm \alpha) \).
Note: Because we can rewrite \( \cos \) in terms of \( \sin \) (and vice-versa) the choice of sine or cosine on the RHS is mostly irrelevant.</description></item><item><title>Harmonics</title><link>https://mohkale.gitlab.io/brain/20201115000924-harmonics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201115000924-harmonics/</guid><description>Refers to the frequencies at which a standing wave can be formed on an object.
The natural frequency of an object is often referred to as its harmonics.
By definition every object has an infinite number of possible harmonics. The first harmonic is defined as a frequency equivalent to half a wavelength across the medium of travel. Or simply the Fundamental Frequency. The second harmonic has twice the frequency and one full wavelength (2 waves each half a wave length).</description></item><item><title>Heap</title><link>https://mohkale.gitlab.io/brain/20210628052741-heap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628052741-heap/</guid><description>A data-structure represented as a binary tree (backed by a [see page 6, special] array), where the root of a node has a property that extends recursively to the left and right sub-trees.
Through this we can show that the root-node of a max-heap is the largest element of that heap and the root for a min-heap is the smallest element.</description></item><item><title>Hearing</title><link>https://mohkale.gitlab.io/brain/20201010230516-hearing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201010230516-hearing/</guid><description>The human ears main function is frequency analysis. Sound [see page 4, enters] through the outer ear, passes through the ear canal and hits the ear drum (tympanic membrane) and passes into the cochlea which passes it to the brain through the auditory nerve.
The hearing system includes the:
Section Construct Purpose [see page 4, Pinna] Ear Entrance Protection and direction estimation Malleus, Incus and Stapes Middle Ear Amplify incoming sound Cochlea Inner Ear Sound waves -&amp;gt; electrical nerve impulses Direction Estimation The slight deviation in how far the sound travels between your 2 ears (as indicated by the pinna) indicates the direction the sound is coming from.</description></item><item><title>Hearing Resolution</title><link>https://mohkale.gitlab.io/brain/20210129013619-hearing_resolution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129013619-hearing_resolution/</guid><description>The resolution of the human hear is commonly converted from frequencies into the [see page 8, bark] scale, with each bark band being a range of frequencies such that two distinct sound-waves with their own unique frequency are perceived as a single sound wave when heard together.
In general we are better at distinguishing low frequency sounds when compared to higher frequency sounds with age playing a part.</description></item><item><title>Hebbian Constant Decay Rule</title><link>https://mohkale.gitlab.io/brain/20210218021214-hebbian_constant_decay_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218021214-hebbian_constant_decay_rule/</guid><description>Is a Hebbian rule with a constant decay. \[ \Delta{w_{ij}} = \alpha v_i v_j - c \]</description></item><item><title>Hebbian Learning</title><link>https://mohkale.gitlab.io/brain/20210218015031-hebbian_learning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218015031-hebbian_learning/</guid><description>Is a form of unsupervised learning based on neural networks using one of a class of learning-rules known as Hebbian rules.
Hebbian learning works in [see page 15, terms] of the spike rate of a neuron, with highly correlated input spikes leading to output spikes. The thing hebbian learning is most concerned with is therefore correlation.
For a neuron \( A \) with \( N \) pre-synaptic neurons we [see page 16, define]:</description></item><item><title>Hebbian Post-synaptically Gated Rule</title><link>https://mohkale.gitlab.io/brain/20210218021524-hebbian_post_synaptically_gated_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218021524-hebbian_post_synaptically_gated_rule/</guid><description>Is a Hebbian rule which expects a minimum-output potential to lead to a positive change in weights. \[ \Delta{w_{ij}} = \alpha (v_i - \theta) v_j \]</description></item><item><title>Hebbian Rule</title><link>https://mohkale.gitlab.io/brain/20210218015857-hebbian_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218015857-hebbian_rule/</guid><description>Are a class of learning-rules which contain in some part the minimal hebbian rule.
Instability The need for multiple Hebbian rules arises from the definition of the minimal-hebbian rule. This rule has no negative components so \( \Delta{w_{ij}} \) will always be positive and therefore always increasing for any two neurons that're firing together. This means the weights can quickly grow exponentially. The minimal-hebbian rule is [see page 27, unstable].</description></item><item><title>Hebbian Synaptically Gated Rule</title><link>https://mohkale.gitlab.io/brain/20210218021731-hebbian_synaptically_gated_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218021731-hebbian_synaptically_gated_rule/</guid><description>Is a Hebbian rule which expects a minimum input and output potential to lead to a positive change in weights. \[ \Delta{w_{ij}} = \alpha (v_i - \theta) (v_j - \theta) \]</description></item><item><title>Hebbs Postulum</title><link>https://mohkale.gitlab.io/brain/20210218015148-hebbs_postulum/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218015148-hebbs_postulum/</guid><description>Neurons that [see page 6, fire together wire together].
When an axon of cell A is near enough to excite cell B or repeatedly or persistently takes part in firing it, some growth process or metabolic change takes place in one or both cells such that A's efficiency, as one of the cells firing B, is increased. -- Donald Hebb, 1949
Essentially Hebbs postulum states that when a pre-synaptic neuron, \( A \), consistently takes part in firing its post-synaptic neuron, \( B \), the synaptic weight between them should increase such that \( B \) is more likely to fire when \( A \) fires.</description></item><item><title>Heterogeneous Relation</title><link>https://mohkale.gitlab.io/brain/20210627012148-heterogeneous_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627012148-heterogeneous_relation/</guid><description>Is an N-Ary relation \( R \subseteq A \times B \) between at least two sets \( A \) and \( B \) [see page 11, where] \( A \neq B \).</description></item><item><title>Heuristic Atmospheric Attenutation</title><link>https://mohkale.gitlab.io/brain/20201023211211-heuristic_atmospheric_attenutation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023211211-heuristic_atmospheric_attenutation/</guid><description>The [see page 19, process] of scaling the illumination an object based on its distance from the light source.
This allows two objects (one in front of the other) to appear visually distinct from one another despite being otherwise identical.</description></item><item><title>Hexal</title><link>https://mohkale.gitlab.io/brain/20210716040839-hexal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210716040839-hexal/</guid><description>Is a number notation using base-16 with digits [0-9] matching base-10 and the letters [A-F] representing the remaining [10-16] values.
Table 1: Association between hex digits and their equivalent decimal values. 0 1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 For example the hex number 1F is \( 1 \times {16}^1 + 15 \times 16^0 = 16 \).</description></item><item><title>Hidden Surface Removal</title><link>https://mohkale.gitlab.io/brain/20201017164432-hidden_surface_removal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201017164432-hidden_surface_removal/</guid><description>The process of removing polygons which aren't visible from a particular viewpoint in world space.
There're a [see page 3, myriad] of HSR algorithms:
Z-buffer (most popular) Scan-line based Area subdivision Depth List or Depth Priority Schemes Z-Buffer relies on a lot of memory and steadily replaced the alternatives as memory prices decreased.</description></item><item><title>Hierarchial Design</title><link>https://mohkale.gitlab.io/brain/20210911154022-hierarchial_design/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911154022-hierarchial_design/</guid><description>Is a UI design based on state-machines where you're restricted from performing certain actions based on the current state. For example a logged-in user can do everything a logged out user can do. An admin can do everything a logged-in user can do. There's a [see page 18, hierarchy] of permissions and access control.
This model suggests a sub-state machine nested inside a logged-in super-state.</description></item><item><title>High Level Animation</title><link>https://mohkale.gitlab.io/brain/20201124200846-high_level_animation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201124200846-high_level_animation/</guid><description>An [see page 37, animation] approach where an object internally transforms itself under the control of a set of rules mimicking a biological process, or acts and reacts to an external stimulus.
Flocking Specify a bunch of [see page 38, rules] for entities in a system and then let them roam the world. Each frame update the entities states based on these rules and observe the emergent behaviour.
eg. boids</description></item><item><title>Higher Level Languages</title><link>https://mohkale.gitlab.io/brain/20220102171342-higher_level_languages/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220102171342-higher_level_languages/</guid><description>The 3rd generation of programming language. Example Fortran, Cobol, Lisp, C, C++, C#, Java.</description></item><item><title>Histogram</title><link>https://mohkale.gitlab.io/brain/20210622031840-histogram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622031840-histogram/</guid><description>Is a graph used to represent continuous data. The key feature of a histogram is that the area of a bar is proportional to the frequency it represents.
When plotting a histogram you need to calculate the frequency density of each bar as the frequency divided by the length of the class (the spread that was measured).
Table 1: An example frequency distribution for the speed of of production in a factory.</description></item><item><title>hledger</title><link>https://mohkale.gitlab.io/brain/20210915230546-hledger/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210915230546-hledger/</guid><description>Is a language for plain-text accounting.
Accounts You declare accounts with the account keyword followed by the account name.
account assets An account can be tagged with a specific type by using a comment.
account assets ; type:A Table 1: List of the available account types and their associated tags. Name Tag Asset A Liabilities L Equity E Revenues R Expenses E Sub-accounts hledger can group accounts into sub-accounts, constructing a tree like structure.</description></item><item><title>Homogeneous Relation</title><link>https://mohkale.gitlab.io/brain/20210627012216-homogeneous_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627012216-homogeneous_relation/</guid><description>Is an N-Ary relation \( R \subseteq A \times B \) between at least two sets \( A \) and \( B \) [see page 11, where] \( A = B \). That is \( R \subseteq A \times A \).
You can [see page 13, visualise] such relations on a graph.</description></item><item><title>Homomorphic Filtering</title><link>https://mohkale.gitlab.io/brain/20210108013244-homomorphic_filtering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210108013244-homomorphic_filtering/</guid><description>A form of filtering where we go from one domain applying a non-linear function and then going back to the original domain.</description></item><item><title>Host</title><link>https://mohkale.gitlab.io/brain/20210719190409-host/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719190409-host/</guid><description>A machine included in a network.</description></item><item><title>HSTS</title><link>https://mohkale.gitlab.io/brain/20210429005306-hsts/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429005306-hsts/</guid><description>On the very first request to a server the browser stores some information about it including whether it only wants to talk over HTTPS. If a later HTTP connection is established the browser rejects it.
[see page 58, Concerns] with this approach are:
The very first request is still vulnerable, if you've always been in a man-in-the-middle attack then it won't work. HSTS info stored in your browser can reveal the sites you've visited even in private mode 😨.</description></item><item><title>HTTP</title><link>https://mohkale.gitlab.io/brain/20210429000447-http_protocol/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429000447-http_protocol/</guid><description>An application layer protocol used for communication between web-browsers and web-servers.
HTTP defines several request methods including GET, POST, HEAD, PUT, DELETE, TRACE, etc. For a comprehensive list with descriptions for the purpose of each method see here.
Requests &amp;amp; Responses A HTTP request is a plain-text query, shown below, with each line ending with carriage-return/line-feed. Requests are defined with the first line showing the request method, path and then the HTTP protocol version.</description></item><item><title>HTTPS</title><link>https://mohkale.gitlab.io/brain/20210429004913-https_protocol/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429004913-https_protocol/</guid><description>Is HTTP [see page 40, over] TLS. Because SSLs Record Protocol splits the data to be transferred into fragments and encrypts all of them, all the HTTP data (headers, and URL parameters) are encrypted by the TLS tunnel when sent over HTTPS.
See [see page 41, process].
Vulnerabilities HTTPS can be vulnerable to man in the middle attacks, specifically attackers may be able to bypass HTTPS at the user level. The [see page 49, goal] is essentially:</description></item><item><title>Huffman Coding</title><link>https://mohkale.gitlab.io/brain/20201029165807-huffman_coding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201029165807-huffman_coding/</guid><description>A coding algorithm for variable length, symbolwise, text compression. See here.
The huffman coding approach uses a [see page 109, deterministic binary prefix-tree] to represent the symbols for a text compression. The idea is we follow a path through a binary tree for each bit 0/1 we encounter in the input stream and once we reach a leaf node we output the character at that node.
Note: A huffman tree is guaranteed to be deterministic.</description></item><item><title>Human Voice Synthesis</title><link>https://mohkale.gitlab.io/brain/20210129010534-human_voice_synthesis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129010534-human_voice_synthesis/</guid><description>The [see page 19, Holmes Parallel Format Synthesiser] computationally models the human speaking apparatus using 12 parameters (updated every 10 seconds) and is capable of producing speech indistinguishable from the real thing.
Most modern synthesizers cheat by copying and pasting speech wave forms. Holmes is approach took a much more fundamental approach.</description></item><item><title>Hyperbola</title><link>https://mohkale.gitlab.io/brain/20210621230542-hyperbola/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621230542-hyperbola/</guid><description>Refers to two curves that are infinite and mirror reflections of each other. These generally have the form \( xy = a^2 \) or in parametric form \( (at, \frac{1}{t}) \).
\begin{figure} \centering \begin{tikzpicture} \begin{axis}[axis lines=middle,samples=400, ymin=-10, ymax=10] \draw[very thin, gray!30, step=1 cm](-3,-2.9) grid (2.9,2.9); \addplot[blue,domain=-3:3] {1/x}; \draw[red!20, dashed, line width=0.5mm] (axis cs:0,-10) -- (axis cs:0,10); \draw[red!20, dashed, line width=0.5mm] (axis cs:-10,0) -- (axis cs:10,0); \node at (1, 2)[circle,fill,inner sep=1.5pt]{x}; \filldraw[black] (1,2) circle (2pt) node[anchor=west] {Intersection point}; \end{axis} \end{tikzpicture} \caption{Demonstration of a hyperbola.</description></item><item><title>Hyperthreading</title><link>https://mohkale.gitlab.io/brain/20210930020626-hyperthreading/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210930020626-hyperthreading/</guid><description>A feature of some computer architectures that allows a single CPU core to appear to the OS as multiple virtual cores. The operating system can schedule processes on these virtual cores but all the processing will be done on a single core CPU.
Each core interleaves processes and threads, allowing it to perform a few instructions for a different thread/process while waiting for something in the background to complete (such as fetching a memory address).</description></item><item><title>i-node</title><link>https://mohkale.gitlab.io/brain/20210718014656-i_node/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718014656-i_node/</guid><description>Is a file system structure pooled near the bottom blocks of the file-system which is used to map names (files/directories) to blocks. Each i-node describes one file.
File data blocks (including directories) live above the i-nodes in higher numbered blocks.
Every i-node contains a list of the disk block numbers used by the file it describes, but it doesn't track the name of the file itself. File names live in a directory structure that simply maps names to i-node numbers.</description></item><item><title>IAAA</title><link>https://mohkale.gitlab.io/brain/20210211060435-iaaa/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211060435-iaaa/</guid><description>Refers to the problems we need to solve when deciding whether a subject is a member of an authorised party that can access an object.
These concerns are: Identification, Authentication, Authorisation and Access Control.</description></item><item><title>Idempotence</title><link>https://mohkale.gitlab.io/brain/20201127014532-idempotence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127014532-idempotence/</guid><description>In computing, an idempotent operation is one that has no additional effect if it is called more than once with the same input parameters. Eg. removing an element from a set. Remove once. Done. Remove the same input again, nothing changes.</description></item><item><title>Identification</title><link>https://mohkale.gitlab.io/brain/20210211060314-identification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211060314-identification/</guid><description>Associating an identity with a subject.</description></item><item><title>Identity Matrix</title><link>https://mohkale.gitlab.io/brain/20210621222803-identity_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621222803-identity_matrix/</guid><description>We define the identity matrix \( I \) as a matrix with \( 1 \) across all its diagonals. For example the 2D identity matrix is
\begin{align*} \begin{pmatrix}
1 &amp;amp; 0 \\\\ 0 &amp;amp; 1 \end{pmatrix} \end{align*}
Multiplying any matrix by this matrix is the same as not multiplying by it at all.</description></item><item><title>Illumination</title><link>https://mohkale.gitlab.io/brain/20201023193652-illumination/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023193652-illumination/</guid><description>We consider how light interacts with an objects surface to determine how it should be colored in.
Note: the angle/orientation of the [see page 5, surface] impacts how we calculate illumination.
Local vs Global Local only approximates reality for a single object in free space (eg. doesn't account for reflection from another source)</description></item><item><title>Imaginary Constant</title><link>https://mohkale.gitlab.io/brain/20210621212637-imaginary_constant/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621212637-imaginary_constant/</guid><description>Is a constant used to represent the square root of the negative number \[ i = \sqrt{-1} \]
\( i \) is usually substituted in place of \( \sqrt{-1} \) in algebraic equations because it's easier to manipulate and interact with.
You can do this using regular surd arithmetic, for example:
\begin{align*} x &amp;amp;= \sqrt{-36} \\
&amp;amp;= \sqrt{36}\sqrt{-1} \\\\ &amp;amp;= 6i \end{align*}
Powers of \(i\) The various powers of \( i \) form a cyclic pattern with repeat invocations cancelling out our inverting the sign of the constant.</description></item><item><title>Imaginary Number</title><link>https://mohkale.gitlab.io/brain/20210830224049-imaginary_number/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830224049-imaginary_number/</guid><description/></item><item><title>Imperative Languages</title><link>https://mohkale.gitlab.io/brain/20220102171425-imperative_languages/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220102171425-imperative_languages/</guid><description>A class of 3rd generation languages where a program specifies how a computation is to be done. Example: C, C++, C#
Such languages have a program state and statements which change that state.</description></item><item><title>Implementation</title><link>https://mohkale.gitlab.io/brain/20210627020027-implementation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627020027-implementation/</guid><description>[see page 5, Implement] a specification so that it can be executed on a computer. This can be understood as an effective solution to the problem posed by the specification.</description></item><item><title>Implicit Differentiation</title><link>https://mohkale.gitlab.io/brain/20210621202237-implicit_differentiation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621202237-implicit_differentiation/</guid><description>Is a form of differentiation targeting implicit functions.
For example consider the equation \( y^2 - 2x + \sin 3x = 16 \). Each of these can be differentiated independently, with any \( y \) terms also being multiplied by \( \frac{\,dy}{\,dx} \).
\begin{align*} \frac{\,d}{\,dx} (y^2) &amp;amp;= 2y \frac{\,dy}{\,dx} \
\frac{\,d}{\,dx} (-2x) &amp;amp;= -2 \
\frac{\,d}{\,dx} (\sin 3x) &amp;amp;= 3 \cos 3x \
\frac{\,d}{\,dx} (16) &amp;amp;= 0 \end{align*}
From this we can re-arrange to find \( \frac{\,dy}{\,dx} \)</description></item><item><title>Implicit Function</title><link>https://mohkale.gitlab.io/brain/20210621202338-implicit_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621202338-implicit_function/</guid><description>A function where both the \( x \) and \( y \) terms are muddled up. For example \( y^2 - 2x + \sin 3x = 16 \)</description></item><item><title>Impulse Response</title><link>https://mohkale.gitlab.io/brain/20201102163141-impulse_response/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102163141-impulse_response/</guid><description>An [see page 15, impulse] signal is an instantaneous pulse of energy, it the same amplitude at all frequencies in the frequency domain.
An impulse signal has a flat frequency-space graph (like white-noise). When passed through a filter the impulse produces the exact same frequency-space graph as the filter. Meaning if our filter has the same frequency-response (shape) as a vowel sound, passing an impulse [see page 17, through] the filter will produce the same vowel sound.</description></item><item><title>In-place Algorithm</title><link>https://mohkale.gitlab.io/brain/20210628050247-in_place_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628050247-in_place_algorithm/</guid><description>An algorithm with constant (\( \mathcal{O}(1) \)) space complexity.</description></item><item><title>Income Statement</title><link>https://mohkale.gitlab.io/brain/20201018231754-income_statement/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018231754-income_statement/</guid><description>Presents revenues and expenses and resulting profit or loss for a specific period of time.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Income is defined as the increase in economic benefit during the accounting period in the form of: - inflows (or enhancements) of [Assets](/brain/20210112040430-assets/) - decrease of [Liabilities](/brain/20210112040528-liabilities/) Income can be from ordinary activities of the company (revenue) or through other means (gains). To understand the difference consider a pizza company selling pizzas to make money (revenue through sales) and happening to sell a van which they weren't using (gain).</description></item><item><title>Incremental Waterfall</title><link>https://mohkale.gitlab.io/brain/20210626202217-incremental_waterfall/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626202217-incremental_waterfall/</guid><description>Is a variant of the waterfall model which consists of [see page 40, multiple] waterfalls running in sequence (increments). The first increment could use the waterfall to design, build, test, etc. one core feature and then another feature could be worked on using a second waterfall. This essentially converts the waterfall model into a iterative design model.</description></item><item><title>Indexing</title><link>https://mohkale.gitlab.io/brain/20201103212129-indexing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201103212129-indexing/</guid><description>IR commonly requires indexing:
Accurately find terms that can be associated with a document (from the document).
Various indexing schemes exist for various purposes, such as:
Dewey Decimal System [see page 13, ACM] - Subfields of CS [see page 14, MeSH] - Medical Subject Headings Manual Indexing Having users (librarians, researchers, etc.) manually index documents for search engines to better search them. This document is in category literature, it contains these relevant terms.</description></item><item><title>Inequalities</title><link>https://mohkale.gitlab.io/brain/20210621192847-inequalities/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621192847-inequalities/</guid><description>An inequality is an expression that expresses a relation between two numbers. For example \( 5 &amp;lt; 10 \) is an inequality.
Warn: When multiplying an inequality by a negative sign, you must reverse the direction of the inequality. For example \( 5 &amp;lt; 10 \rightarrow -5 &amp;gt; -10 \).
Solving Quadratic Inequalities You may sometimes be asked to find the range of values for which a formula, such as a quadratic equation, is within some range.</description></item><item><title>Infinite Impulse Response Filter</title><link>https://mohkale.gitlab.io/brain/20201121012641-infinite_impulse_response_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201121012641-infinite_impulse_response_filter/</guid><description>A filter with more than 1 poles.
For any finite input signal (limited number of elements) the output of the filter could be see page 5, infinite due to the filter having feedback loops unlike a IIR-filter.
See [see page 6, here] for advantages vs disadvantages. Highlights:
Depends on previous outputs of the filter (recursive-design/feedback-loops). [see page 6, Examples] of IIR filters which all approximate the ideal Brickwall Filter include:</description></item><item><title>Inflexion Point</title><link>https://mohkale.gitlab.io/brain/20210621235530-inflexion_point/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621235530-inflexion_point/</guid><description>A stationary point where the gradient changes sign.
Stationary points don't always have to change the sign of the gradient, the gradient can simply drop to 0 momentarily and then continue increasing in the same direction it was going on before the stationary point (as shown in fig:inflexion-point-demo the gradient is increasing from -5 to 0 where it drops to 0, and then it's increasing from 1 to 5).
\begin{figure} \centering \begin{tikzpicture} \begin{axis}[axis lines=center, xmin=-5, xmax=5, ymin=-5, ymax=5, domain=-5:5, grid=both] \addplot[color=green]{x^3};, \addplot[only marks] coordinates {(0, 0)};, \end{axis} \end{tikzpicture} \qquad \caption{A graph with a single inflexion point.</description></item><item><title>Information Extraction</title><link>https://mohkale.gitlab.io/brain/20201210181418-information_extraction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201210181418-information_extraction/</guid><description>The [see page 6, task] of creating semantically annotated text from an unstructured information.
Information extraction is essentially structuring (in db, XML tagging, etc.) the annotated data we parse from unstructured sources, this can then by [see page 7, applied] for summarising, index creation or searching/analysis.
Kinds of information can [see page 8, include]:
Type Meaning Entities Persons, organisations, locations, times, etc. Relationships Links between entities Events Succession events, occurrences, etc.</description></item><item><title>Information Hiding</title><link>https://mohkale.gitlab.io/brain/20210924030618-information_hiding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210924030618-information_hiding/</guid><description>Is the concept of revealing as little information in a class as possible.</description></item><item><title>Information Modelling</title><link>https://mohkale.gitlab.io/brain/20210814215049-information_modelling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210814215049-information_modelling/</guid><description>Is the process of modelling the business domain; identifying the main business concepts and relationships.
Table 1: Listing of various see page 4, [terms] used in information modelling. Term Description Example Actors Stakeholders or agents using a system Borrower, Clerk, etc. Objects An object in a system Book, Journal, Magazine, etc. Attributes Properties tied to an object, stakeholder, etc.</description></item><item><title>Information Retrieval</title><link>https://mohkale.gitlab.io/brain/20201012205044-information_retrieval/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201012205044-information_retrieval/</guid><description>The [see page 8, task] is given a large static document collection and an information need (query) find all documents relevant to the query. This is a possible application of text processing. A common IR system is a Web Search Engine.
IR results can be presented as an:
unsorted list ranked list clusters (group results by shared themes, for query &amp;quot;jaguar&amp;quot; one cluster can be car related, the other is animal related).</description></item><item><title>Information Retrieval Evaluation</title><link>https://mohkale.gitlab.io/brain/20201020002840-ir_evaluation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020002840-ir_evaluation/</guid><description>The evaluation of effectiveness for a information retrieval system is the relevance of the retrieved documents. This is generally judged in a binary way (either is or isn't relevant) because judging countless possible options for relevance isn't practical.
Other possible factors are:
user effort / ease of use (complicated query bad) response time form of presentation We test relevance in practical terms using a [see page 5, gold standard] data set with:</description></item><item><title>Init</title><link>https://mohkale.gitlab.io/brain/20210717024656-init/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717024656-init/</guid><description>Is a special computer process that spawns several housekeeping processes.
This process performs the following steps in order:
Check and make sure disks are OK. Start several essential daemons such as a print spooler or web server. Prepare for users: Start a copy of the getty program to initialise a virtual console that can watch the screen and keyboard. init may actually spawn several such terminals, each able to connect to a different keyboard+monitor, but you'll rarely see more than one at once.</description></item><item><title>Injection</title><link>https://mohkale.gitlab.io/brain/20210626024849-injection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626024849-injection/</guid><description>A function that has each output mapped to by at most one input.
Note: A function is [see page 31, injective] if each element in the co-domain has a unique pre-image.</description></item><item><title>inode</title><link>https://mohkale.gitlab.io/brain/20211010180636-inode/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010180636-inode/</guid><description>Is a file or directory. Technically an inode contains metadata about the file alongside pointers to disk-blocks on the hard-disk that the file can be read or written to.
One thing to note about inodes is that they don't contain file-names. Instead file-names are stored in directories and the file-name entry points back to the inode which will direct the OS to where the data for the file is stored. This facility means that multiple file-names can point to the same files, allowing you to create hard-links within the file-system.</description></item><item><title>Insertion Sort</title><link>https://mohkale.gitlab.io/brain/20210628051506-insertion_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628051506-insertion_sort/</guid><description>A sorting algorithm that replicates how one orders [see page 11, playing cards].
for j in range(1, len(arr)): key = arr[j] i = j - 1 while i &amp;gt;= 0 and arr[i] &amp;gt; key: arr[i + 1] = arr[i] i -= 1 arr[i + 1] = key Code Snippet 1: Insertion sort implementation. alg:insertion-sort You can see the insertion sort algorithm in alg:insertion-sort. The main idea behind insertion sort is to compare each element we encounter with all the elements before it and then shuffle it down until we find the first element smaller than it.</description></item><item><title>Integer</title><link>https://mohkale.gitlab.io/brain/20210718011006-integer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718011006-integer/</guid><description>Is a primitive data-type for representing integer numbers.
Integers are normally stored as either words or pairs of words. One 64-bit machine word is the most common integer representation supporting \( 1.8446744 \times 10^{19} \).
Twos Complement Is a common notation for representing negative values with integers. In this notation the left most bit is a sign bit. That is the value of that bit is negative when its a 1 and the remaining bits are positive and can be used to re-balance the integer.</description></item><item><title>Integration</title><link>https://mohkale.gitlab.io/brain/20210621205907-integration/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621205907-integration/</guid><description>Is the reverse of differentiation. For a function \( f(x) \) we call its derivative \( \int f(x) \,dx \).
Consider a simple function \( y = ax^2 + bx +c \). If we differentiate \( y \) with respect to \( x \) using the rule \( \times \) by power, decrement power, we get \( \frac{\,dy}{\,dx} = 2ax + b \). If we now try to repeat this process in reverse we increment the power, then divide by this \( \text{power} + 1 \), to get \( \int \frac{\,dy}{\,dx} \,dx = \frac{2ax^2}{n+1} + \frac{bx}{1} + k \) with \( k \) being the constant \( c \) that we lost when we differentiated \( y \).</description></item><item><title>Integration Platform as a Service</title><link>https://mohkale.gitlab.io/brain/20201127203108-ipaas/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127203108-ipaas/</guid><description>With iPaaS, users can develop integration flows that connect applications residing in the cloud or on-premises and then deploy them without installing or managing any hardware or middleware.</description></item><item><title>Integrity</title><link>https://mohkale.gitlab.io/brain/20210211054112-integrity/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211054112-integrity/</guid><description>Protecting information from being modified by unauthorised parties.</description></item><item><title>Intellectual Property</title><link>https://mohkale.gitlab.io/brain/20201023223845-intellectual_property/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023223845-intellectual_property/</guid><description>.org-center { margin-left: auto; margin-right: auto; text-align: center; } The [see page 2, [products](MGT388-law-w04)], results and rewards of human intellectual and commercial endeavour.</description></item><item><title>Intelligent Agents</title><link>https://mohkale.gitlab.io/brain/20200705013014-intelligent_agents/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200705013014-intelligent_agents/</guid><description>Are a form of rational agent and the backbone of our approach to AI.</description></item><item><title>Intention</title><link>https://mohkale.gitlab.io/brain/20201018223345-intention/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018223345-intention/</guid><description>An intention to create legal relations is a core part of the creation of a contract.
For example:
If you give me a ride to work I&amp;#39;ll mow your lawn This comes off as more of a social contract rather than something that has an intention to create legal relations. I doubt I'll be sued if I don't mow their lawn after they give me a ride.
Generally it's up to the claimant to prove this intention.</description></item><item><title>Inter-Process Communication</title><link>https://mohkale.gitlab.io/brain/20211009012950-inter_process_communication/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009012950-inter_process_communication/</guid><description>Is the concept of communicating between processes.
This can be done using:
Named or unnamed pipes. Sockets. Memory mapping. Files. Signals.</description></item><item><title>Internal Cache</title><link>https://mohkale.gitlab.io/brain/20210717215014-internal_cache/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717215014-internal_cache/</guid><description>Is a kind of memory that's on-chip.</description></item><item><title>Internal Fragmentation</title><link>https://mohkale.gitlab.io/brain/20211002233741-internal_fragmentation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002233741-internal_fragmentation/</guid><description>Refers to the memory left-over after a split in malloc.
For example if we have a hole of size 16KiB and need to allocate 2KiB, we can split it into a 2KiB result and 14KiB of internal fragmentation.</description></item><item><title>Internet</title><link>https://mohkale.gitlab.io/brain/20210428233801-internet/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428233801-internet/</guid><description>Millions of computing devices each connected to each other through communication links (fiber, copper, radio, satellite).
The internet is [see page 8, subdivided] into several groupings ranging from a global ISP, regional ISP, home network etc.
Shortcomings of the internet? The internet itself has various [see page 20, shortcomings]:
No confidentiality, every intermediate party in a request transfer can observe the contents of what we transmit. No integrity, there's nothing in the protocol itself stopping intermediate points from manipulating the packets in transit.</description></item><item><title>Interpolative Shading</title><link>https://mohkale.gitlab.io/brain/20201023205108-interpolative_shading/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023205108-interpolative_shading/</guid><description>[see page 26, How] we spread an illumination value across a polygon. This involves:
determining the intensity of each polygon. determining which pixels the polygon takes up in screen space. determining the intensity of each pixel in the polygon. Colors are generally multiplied by the intensity to determine the final color of a pixel.
Interpolative shading can [see page 29, fool the eye] into seeing polygons as a smooth surface.</description></item><item><title>Interpreted Language</title><link>https://mohkale.gitlab.io/brain/20210718023703-interpreted_language/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718023703-interpreted_language/</guid><description>Is a programming language that is interpreted by an interpreter program which translates the source code into computations and system calls on the fly. The source code has to be reinterpreted each time the code is executed.
Interpreted languages are generally slower and more restricted than their compiled counterparts however they tend to be easier to program and more forgiving of errors.
Scripting Languages Interpreted languages with high-level operators designed for gluing together computations.</description></item><item><title>Interrupt</title><link>https://mohkale.gitlab.io/brain/20210717185313-interrupt/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717185313-interrupt/</guid><description>Is a means of communication between the CPU and the OS kernel.
Table 1: Listing of the kinds of things that can initialise an interrupt. Source Description CPU Exceptions such as divide by zero or page faults. Devices Hardware interrupts such as input being available. CPU instruction Traps such as syscalls or breakpoints. It's the operating systems job to watch for interrupts.</description></item><item><title>Interrupt Request</title><link>https://mohkale.gitlab.io/brain/20210717191106-interrupt_request/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717191106-interrupt_request/</guid><description>Refers to a request each hardware device has to give at boot to register the numbered interrupts it'll use. The system uses this to attach the appropriate interrupt handlers at those interrupts. For example you don't want to associate a keyboard interrupt handler to a hardware clock.
If two devices try to register the same IRQ interrupts will sometimes be dispatched to the wrong handler which in the best case locks up the device and worst case cause the OS to flake out or crash.</description></item><item><title>Invention Protection</title><link>https://mohkale.gitlab.io/brain/20201104175329-invention_protection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201104175329-invention_protection/</guid><description>Most [see page 4, inventions] produce solutions to problems (eg. food preservation). Solutions can also cause problems which must be solved. There's a constant need to innovate.
A key approach to invention protection are patents.</description></item><item><title>Inventory Holding Period</title><link>https://mohkale.gitlab.io/brain/20201021172333-inventory_holding_period/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021172333-inventory_holding_period/</guid><description>How [see page 26, long] a company can hold its inventory before its no longer valuable (eg. Food Expires).
\[ \frac{\text{Closing Inventory}}{\text{Cost of Sales}} \times 365 \text{days} \]
Many companies use Just In Time inventories to manufacture and ship products just when their required.</description></item><item><title>Inverse Fourier Transform</title><link>https://mohkale.gitlab.io/brain/20201110181625-inverse_fourier_transform/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110181625-inverse_fourier_transform/</guid><description>The process used to reverse a lossless fourier-transform.
\[ S(nT) = \frac{1}{N} \sum^{N-1}_{S_p \times e^{j \frac{2\pi np}{N}}, n = 0,1,\ldots,{N-1}} \]</description></item><item><title>Inverse Function</title><link>https://mohkale.gitlab.io/brain/20210621190824-inverse_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621190824-inverse_function/</guid><description>Often written as \( f^{-1}(x) \) is a function that reverses the affect of another function \( f(x) \). That is it maps from the range of the function \( f(x) \) back to its domain.
The general process of constructing an inverse function from the equation of a function \( f(x) \) is:
write \(y\) instead of \( f(x) \) on the LHS. Replace each occurrence of \(y\) on both sides of the equation with \( x \) and vice-versa.</description></item><item><title>Inverse Matrix</title><link>https://mohkale.gitlab.io/brain/20210621223649-inverse_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621223649-inverse_matrix/</guid><description>\( M^{-1} \) is the mathematical inverse of a matrix \( M \). That is to say multiplying an inverse-matrix by its original matrix gives the identity matrix \[ M \times M^{-1} = I \]
For a 2D matrix \( M \) the inverse is \( \frac{1}{det(M)} adj(M) \).</description></item><item><title>INVEST</title><link>https://mohkale.gitlab.io/brain/20210626234228-invest/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234228-invest/</guid><description>Is an [see page 6, anagram] used to help build descriptions for a user story. It consists of:
Independent: Stories should be self contained with no dependencies. When necessary use a higher level abstraction to combine details across multiple stories. Negotiable: User stories can be changes/rewritten until implementation. Valuable: Must deliver value to the end user. Estimatable: The team should be able to use them for planning. Three common failures involve developers lacking technical knowledge, domain knowledge or the story being too big.</description></item><item><title>Investment</title><link>https://mohkale.gitlab.io/brain/20210110030330-investment/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110030330-investment/</guid><description>Is the [see page 3, foregoing] of resources now in anticipation of consuming more in the future.
I.E. we sacrifice in the present to take more in the future (eg. opening a new branch).</description></item><item><title>Invitation to Tender</title><link>https://mohkale.gitlab.io/brain/20201002002554-invitation_to_tender/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201002002554-invitation_to_tender/</guid><description>Are not an offer, its an [see page 17, invitation] for other parties to submit offers.
We know it's not an offer because we reserve the right to reject it, we don't have to say Yes.
For example an auction:
Consider a bottle in a window shop with a price label. That price label isn't an offer because the shop owner retains the ability to reject a prospective customers offer to purchase it.</description></item><item><title>IP</title><link>https://mohkale.gitlab.io/brain/20210428235203-ip/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428235203-ip/</guid><description>The internet protocol is the networking layer of the internet stack. It describes how a stream of bytes are transmitted between two hosts on the internet network.
[With TCP/IP] people who write network protocols almost never have to think about all the packetizing, packet reassembly, error checking, checksumming, and re-transmission that goes on below that level.
IP is implemented using a mixture of a lower level internet protocol described below and the higher level transfer control protocol.</description></item><item><title>IP Address</title><link>https://mohkale.gitlab.io/brain/20210719190600-ip_address/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719190600-ip_address/</guid><description>Is the address of a host in the internet protocol.
You can retrieve the IP address for each interface on your device using ifconfig (ipconfig on windows) command. The getaddrinfo syscall converts a human readable domain name into an IPv4 and IPv6 address through the DNS system (take care to free it afterwards using freeaddrinfo). The getnameinfo syscall converts a binary IP-address (a literal number address) into one of the readable forms described below.</description></item><item><title>IP Infringement</title><link>https://mohkale.gitlab.io/brain/20201023224126-ip_infringement/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023224126-ip_infringement/</guid><description>The violation of someones IP.
There're several laws related to ip protection, including:
Law of Confidential Information Law of Copyright Remedies Search Orders Let us search through your data to prove your violating our IP.
Injunctions Final Injunctions Interlocutory (Interim) Injunctions - Prevents defendent from continuing an alleged infringement prior to an impending court case. Freezing Orders - Freeze bank accounts in case their trying to transfer money from infringement out of account.</description></item><item><title>IPA</title><link>https://mohkale.gitlab.io/brain/20210129041806-ipa/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129041806-ipa/</guid><description>The International Phonetic Alphabet, used as the standard phonetic writing system.
Different languages generally use a different [see page 9, subset] of the IPA.
The IPA is [see page 11, divided] into:
consonants vowels Non-pulmonic consonants (don't use lungs), (eg. clicks) Suprasegmentals - Stress, Accent, Tone Diacritics - Find phonetic detail : - to indicate the previous value is a long vowel, not a short one (eg. eh vs ee).</description></item><item><title>IR vs. IE</title><link>https://mohkale.gitlab.io/brain/20201210182717-ir_vs_ie/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201210182717-ir_vs_ie/</guid><description>How information-retrieval differs from information-extraction.
IR is based around retrieving relevant documents in a collection from a user-query. Which document is most relevant to my hobbies?
IE is [see page 18, based] more around extracting semantic meaning from document collections. &amp;quot;Given this text can you tell where john is going on Monday?&amp;quot;</description></item><item><title>Irreflexive Relation</title><link>https://mohkale.gitlab.io/brain/20210627012330-irreflexive_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627012330-irreflexive_relation/</guid><description>Is a homogeneous relation where nothing is related to itself. \( \forall x \in A \neg (x R x) \).</description></item><item><title>ISA</title><link>https://mohkale.gitlab.io/brain/20210717015503-isa/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717015503-isa/</guid><description>Is a bus type, which except for some minor details, is the same type used in the original IBM PCs in the 1980s. It is no longer used.</description></item><item><title>Iterative Design Model</title><link>https://mohkale.gitlab.io/brain/20210626201453-iterative_design_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626201453-iterative_design_model/</guid><description>A software development model that build programs incrementally, in pieces. At each increment you have a working solution, but it may not cover any or all of the features required by the system.
Iterations are shorter meaning you have more room for [see page 45, refining] requirements in-between them.</description></item><item><title>Journal</title><link>https://mohkale.gitlab.io/brain/20211010181221-journal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010181221-journal/</guid><description>Is a piece of metadata stored on the superblock that logs changes to the file-system.
Essentially whenever the file-system is about complete a potentially expensive operation, it writes what it is going to do in a journal. In case of a crash or failure one can step through the journal and see which files are corrupt and fix them.</description></item><item><title>K-Means Clustering</title><link>https://mohkale.gitlab.io/brain/20210306160550-k_means_clustering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210306160550-k_means_clustering/</guid><description>The most common clustering implementation, where we [see page 6, visualise] points in some N-dimensional data-space Each point has a certain degree of similarity to each cluster and is assigned to the cluster to which its closest to by some distance measure (example: Euclidean distance).
The name [see page 11, K-means clustering] comes from having \( k \) prototypes and assigning a data-point to the closest prototype.
Mathematically we perform a clustering using a [see page 6, prototype] \( m_k \) (AKA: centroid, mean, \( w_k \)) for some cluster \( k \) in the set of clusters in the range \( i \).</description></item><item><title>Kanban Board</title><link>https://mohkale.gitlab.io/brain/20210626232855-kanban_board/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626232855-kanban_board/</guid><description>Is an agile development tool that helps to [see page 57, visualise] the workflow of a software project, limit the total amount of work being done at once and measure &amp;amp; optimise the flow of development. A Kanban board is a [see page 58, board] divided into several sections with stickies corresponding to tasks to work on. As tasks are finished in one section their moved along to the next section until their in the final section and seen as completed.</description></item><item><title>Kernel</title><link>https://mohkale.gitlab.io/brain/20210717023301-kernel/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717023301-kernel/</guid><description>Is a part of the operating system, closer to the hardware, that provides lower level services. This includes:
Device Drivers Process Management Memory Management System Calls Once the kernel is loaded it looks around find the rest of the available hardware and then prepare to run programs. It does by poking around at special bus addresses that are likely to have controller cards and listening at them for commands.</description></item><item><title>Kernel Ring</title><link>https://mohkale.gitlab.io/brain/20210920165242-kernel_ring/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210920165242-kernel_ring/</guid><description>Is a kernel protection mechanism that prevents most user-space programs from interacting or reverse-engineering hardware details they don't have the privilege to use.</description></item><item><title>Key Agreement Protocol</title><link>https://mohkale.gitlab.io/brain/20210429001959-key_agreement_protocol/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429001959-key_agreement_protocol/</guid><description>Is an implementation of perfect forward secrecy where both the client and recipient contribute to the creation of a secure session key.
The general algorithm for a sender/reciever pair of Alice/Bob is:
Alice &amp;amp; Bob declare and share two numbers between themselves.
A large prime number \( p \), and A number \( g, 1 &amp;lt; g &amp;lt; p \). These don't need to be secret so they can be sent over an unsafe channel.</description></item><item><title>Keyed-Stream Cipher</title><link>https://mohkale.gitlab.io/brain/20210215030757-keyed_stream_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215030757-keyed_stream_cipher/</guid><description>Is a variant of a stream cipher where the stream is actually generated using some keyed stream generator.</description></item><item><title>Kinds of Intelligence</title><link>https://mohkale.gitlab.io/brain/20200704220043-intelligence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200704220043-intelligence/</guid><description>Brains Cause Minds (1992, John Searle). Laws of Thought Syllogisms (initially proposed by Aristottle pg. 24) is a way to get true conclusions from true premises.
This approach eventually lead to the creation of the field of Logic.
The so called logicist tradiation in AI hopes to build on logic to create intelligent systems.
Issues It's not easy to take informal knowdledge and state it in formal terms.</description></item><item><title>KISS</title><link>https://mohkale.gitlab.io/brain/20210626232230-kiss/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626232230-kiss/</guid><description>Is a design principle that states most systems work best when kept simple rather than being over-complicated.</description></item><item><title>Kronecker Delta</title><link>https://mohkale.gitlab.io/brain/20210306205456-kronecker_delta/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210306205456-kronecker_delta/</guid><description>Kronecker delta.</description></item><item><title>Kruskal's Algorithm</title><link>https://mohkale.gitlab.io/brain/20210622174906-kruskals_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174906-kruskals_algorithm/</guid><description>Is an algorithm to find the minimum spanning tree of a graph \( G \).
Formulation The algorithm is:
Sort the edges into ascending order. Choose an edge with the minimum weight and join on a sub-graph. Find the next edge of minimum weight that does not make cycle and add that to the sub-graph. Repeat step 3 until all vertices are connected.</description></item><item><title>Laplace Smoothing</title><link>https://mohkale.gitlab.io/brain/20201125174830-laplace_smoothing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201125174830-laplace_smoothing/</guid><description>A form of [see page 34, smoothing] that can be applied to a classifier to try to mitigate incorrect classifications.
At a basic level:
When we encounter a term that isn't in our corpus of word-&amp;gt;sentiment classifications we consider that word to have a 0% correlation with a given sentiment. This turns our classification to 0 because it's defined as a large product. Which means a single missing word can completely invalidate a classification.</description></item><item><title>Latency vs. Throughput</title><link>https://mohkale.gitlab.io/brain/20201127021735-latency/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127021735-latency/</guid><description> Term Meaning Latency The time to perform some action or produce some result. Throughput The number of such actions/results per unit of time.</description></item><item><title>Law</title><link>https://mohkale.gitlab.io/brain/20201001232105-law/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201001232105-law/</guid><description>How the law is made Laws are formulated in statutes/legislations and then accepted by parliament or by precedent (by a judge) based on similair factors in earlier cases compared to current cases.
By similair factors I mean matching like facts based on material facts (eg. what happened, where, how, what lead up to it?).
Courts are divided into multiple categories:
The supreme court has the highest value and sets the precedence for other lower level courts.</description></item><item><title>Law of Confidential Information</title><link>https://mohkale.gitlab.io/brain/20201023225704-law_of_confidential_information/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023225704-law_of_confidential_information/</guid><description>The laws upholding a person's obligation to keep a secret or maintain [see page 5, confidentiality]. It's used to protect ideas and information (even when they lack a tangible form).
For example you can send your book to a printer to get it printed and you can trust that the printer won't keep the pages and sell more copies of your book without your consent.
Governed by case law not statute.</description></item><item><title>Law of Copyright</title><link>https://mohkale.gitlab.io/brain/20201023232455-law_of_copyright/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023232455-law_of_copyright/</guid><description>Protect tangible expression of an idea (NOT the idea itself) such as: Art, Music, Literature, Software etc. Copyright can last 70 years after the authors death according to [see page 9, CDPA].
Copyright is governed by statute law (however case law is considered in legislation).
Copyright is automatically assigned to a new creation provided that:
The work is original The work is recorded in material form. A substantial part of the work is reproduced without permission.</description></item><item><title>Layered Architecture</title><link>https://mohkale.gitlab.io/brain/20210906023654-layered_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906023654-layered_architecture/</guid><description>A Software Architecture which uses logical separation of display, processing, and data-storage. It applies horizontal [see page 11, layers] with strong coupling across them.
\begin{figure} \centering \begin{tikzpicture}[line/.style={very thick, dashed}] \begin{umlpackage}{Layered Architecture}\end{umlpackage} \begin{umlpackage}[right=0.6cm of Layered Architecture]{Main Java Program}\end{umlpackage} \begin{umlpackage}[right=0.6cm of Main Java Program]{Java Virtual Machine}\end{umlpackage} \draw [line, -&amp;gt;, transform canvas={yshift=0.2cm}] (Layered Architecture) -- (Main Java Program); \draw [line, &amp;lt;-, transform canvas={yshift=-0.2cm}] (Layered Architecture) -- (Main Java Program); \draw [line, -&amp;gt;, transform canvas={yshift=0.</description></item><item><title>Learning Algorithms</title><link>https://mohkale.gitlab.io/brain/20210206035631-learning_algorithms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206035631-learning_algorithms/</guid><description>Describes how computer system can learn over time how to intelligently solve problems. This can involve learning from sample data how to classify some data or observe similarities in data sets to cluster them together.
You can compare and contrast the various approaches [see page 16, here].</description></item><item><title>Learning Curve</title><link>https://mohkale.gitlab.io/brain/20210305030216-learning_curve/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210305030216-learning_curve/</guid><description>A graph plotting epochs along the X-axis and error (or accuracy) of a learning model on the Y-axis.
These plots can help to diagnose whether the model has over learned, under learned, or is suitably fit to the training dataset.</description></item><item><title>Leasing</title><link>https://mohkale.gitlab.io/brain/20210110055318-leasing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110055318-leasing/</guid><description>An agreement where a customer can [see page 10, lease] an asset. They pay for it in one instalment (or periodically) but don't own the asset, they simply have the right to use it. Once the lease is payed off the customer has essentially bought the asset and ownership transfers to them.</description></item><item><title>Least Common Multiple</title><link>https://mohkale.gitlab.io/brain/20210830224813-least_common_multiple/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830224813-least_common_multiple/</guid><description>Is the smallest positive integer that can be divided by two numbers \( a, b \), written as \( \lcm(a,b) \).
This is often written in terms of the greatest common divisor of \( a, b \).
\begin{align} \lcm(a, b) = \frac{|a \times b|}{\gcd (a,b)} \label{eq:lcm} \end{align}</description></item><item><title>Least Squares Regression Line</title><link>https://mohkale.gitlab.io/brain/20210622170407-least_squares_regression_line/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622170407-least_squares_regression_line/</guid><description>Is a formula for the line-of-best fit for the data plotted on scatter-diagram. It's defined as a straight line that always goes through \( (\bar{x}, \bar{y}) \). The goal of the least squares regression line is to minimise the total residual space between the line and each point on the graph. I.E. To provide a best fit to the data.
Warn: A best fit line only works when there's positive or negative correlation.</description></item><item><title>Lexicon</title><link>https://mohkale.gitlab.io/brain/20201117011357-lexicon/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201117011357-lexicon/</guid><description>An approach for sentiment-analysis which uses a [see page 9, lexicon] to sentiment words.
We define a [see page 27, lexicon] as a list of opinion/emotion words mapping to a polarity. For example:
Word Polarity Horrible Bad Great Good General Algorithm Classify text as subjective if it has some fixed number of words in the lexicon. Count the number of +ve and -ve connotations and classify text as +ve, neutral, -ve.</description></item><item><title>Liabilities</title><link>https://mohkale.gitlab.io/brain/20210112040528-liabilities/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210112040528-liabilities/</guid><description>Present [see page 24, obligations] of an entity which is expected to use up resources in the pursuit of economic benefits.
Liabilities are either:
Current - obligations expected to be settled in its normal operating cycle (or one year). eg. Salaries, Taxes. Non-current - Liabilities that're not current.</description></item><item><title>Life Cycle Analysis</title><link>https://mohkale.gitlab.io/brain/20201106023132-life_cycle_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106023132-life_cycle_analysis/</guid><description>A [see page 34, life cycle] is the duration of a project, product or companies existence.
This is most useful for pricing products with a dynamic environment, where absorption-costing isn't relevant. A dynamic environment includes R&amp;amp;D with high initial cost per unit, staff training, [see page 35, etc]. See [see page 36, explanation] of how the price will fluctuate.
See also [see page 39, discounting] early or late into life cycle to guarantee product-sales.</description></item><item><title>Limited Company</title><link>https://mohkale.gitlab.io/brain/20201011180110-limited_company/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201011180110-limited_company/</guid><description>An [see page 13, artificial person] created by the law with a separate life from its owners and a perpetual existence.
The company must take responsibility for its own debts and losses but its owners are granted limited liability. With restrictions placed on the withdrawal of equity.
Financial statements are publicly available annually.
It is governed by a board of directors elected by the shareholders.
The [see page 4, companies act] sets the rules for the corporate governance of new companies.</description></item><item><title>Linear Cryptanalysis</title><link>https://mohkale.gitlab.io/brain/20210216004852-linear_cryptanalysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216004852-linear_cryptanalysis/</guid><description>A [see page 2, form] of cryptanalysis (against many block-ciphers) which exploits the deviation (bias) in the calculation of certain pairs of linear-expressions (of the input and of the output) of a substitution permuation network.
We define a linear expression as simply the xor sum of a subset of the bits in an input and output block.
Note: If we have enough plaintext ciphertext pairs, we can perform linear-analysis with as little as a 50.</description></item><item><title>Linear Expressions</title><link>https://mohkale.gitlab.io/brain/20210216014320-linear_expressions/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216014320-linear_expressions/</guid><description>An expression defined as an XOR sum of a number of bits of some piece of data that always evaluates to a 0/1 (true/false) value with some bias (for example a binary number \(Y\) could have a linear-expression defined as \( Y_1 \xor Y_2 \xor Y_3 \)).
Note: The bias in a linear-expression can be exploited to attack a system.
Note: In these equations \(Y_1\) is the left-most bit and \(Y_n\) is the right-most.</description></item><item><title>Linear Feedback Function</title><link>https://mohkale.gitlab.io/brain/20210215032150-linear_feedback_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215032150-linear_feedback_function/</guid><description>Is a function used by LFSR to calculate the feedback-bit for the current state.
For [see page 9, example]: the feedback-function can be set to \[ f(X) = X_5 \xor X_8 \xor X_10 \] To mean we calculate the feedback-bit by XORing the \nth{5}, \nth{8} and \nth{10} bits of the current state.</description></item><item><title>Linear Feedback Shift Registers</title><link>https://mohkale.gitlab.io/brain/20210215031750-linear_feedback_shift_registers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215031750-linear_feedback_shift_registers/</guid><description>A [see page 9, way] to quickly generate a continuous sequence of random bits using state (binary number) transitions.
Note: An instance of an LFSR (state + LFF) is often referred to as a register.
Given a current state we:
Calculate a feedback-bit using the current-state and a linear-feedback function. We extract the right-most bit as the stream-bit and right-shift. We insert the feedback-bit to the left-most position. We return the stream-bit as the current output of the LFSR.</description></item><item><title>Linear Filters</title><link>https://mohkale.gitlab.io/brain/20201116230401-linear_filters/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201116230401-linear_filters/</guid><description>A filter which [see page 3, obeys] the principle of super position.
Principle of super position: the input is linearly proportional to the output.
\begin{align*}
x\_1[n] &amp;amp;\longrightarrow y\_1[n] \\\\ x\_1[n] + x\_2[n] &amp;amp;\longrightarrow y\_1[n] + y\_2[n] \\\\ a * x_1[n] + b * x_2[n] &amp;amp;\longrightarrow a * y_1[n] + b * y_2[n] \end{align*}</description></item><item><title>Linear Prediction</title><link>https://mohkale.gitlab.io/brain/20210107224552-linear_prediction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210107224552-linear_prediction/</guid><description>The ability to [see page 2, predict] the next sample of speech from a weighted sum of previous samples. This exploits the redundancy arising from the Stationary Assumption.
This can be done with 10-15 prediction-coefficients (previous samples).
We define [see page 3, prediction-error] as the difference between the predicted signal and the actual signal. Therefore our goal with linear prediction is to minimise the sum squared prediction-error (residual signal) over a frame of speech data.</description></item><item><title>Linear Programming</title><link>https://mohkale.gitlab.io/brain/20210622220100-linear_programming/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622220100-linear_programming/</guid><description>Is a decision making process where you form constraints from a problem that needs to be solved, plot it and then use a sliding line or corner checking to optimise some reward or minimise some cost.
The actual process is:
Identify the decision variables: These are the quantities we need to find to solve the problem, we denote them by \( x, y \). Identify the objective to be maximised/minimised: For example the maximum profit or minimum cost.</description></item><item><title>Linear Relations</title><link>https://mohkale.gitlab.io/brain/20210216015559-linear_relations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216015559-linear_relations/</guid><description>Refers to the relationship between two linear expressions.</description></item><item><title>Linear Time Sorting</title><link>https://mohkale.gitlab.io/brain/20210628053604-linear_time_sorting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053604-linear_time_sorting/</guid><description>Is a class of sorting algorithms which by-pass the lower-bound of comparison based sorting by using more data or [see page 15, exploiting] the type of the information being sorted.</description></item><item><title>Linear Transformations</title><link>https://mohkale.gitlab.io/brain/20210621225021-linear_transformations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621225021-linear_transformations/</guid><description>A transformation is linear when both the following formulae hold.
\begin{align} T(k \begin{pmatrix}
x \\\ y \end{pmatrix}) &amp;amp;=
k T \begin{pmatrix} x \\\ y \end{pmatrix} \\\\ T( \begin{pmatrix}
x\_1 \\\ y\_1 \end{pmatrix} + \begin{pmatrix}
x\_2 \\\ y\_2 \end{pmatrix}) &amp;amp;=
T( \begin{pmatrix} x\_1 \\\ y\_1 \end{pmatrix}) + T( \begin{pmatrix}
x\_2 \\\ y\_2 \end{pmatrix}) \end{align}
This can be asserted trivially be inserting possible values for \( (x,y) \) and checking whether these conditions hold.</description></item><item><title>Lines of Code</title><link>https://mohkale.gitlab.io/brain/20210626234946-lines_of_code/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234946-lines_of_code/</guid><description>A code metric that simply counts the lines of code, excluding comments and blank lines.
There're several, quite obvious, [see page 37, downsides] with this approach. Most eloquently put by Bill Gates.
Measuring software productivity by lines of code is like measuring progress on an aeroplane by how much it weighs.
[see page 39, Bill Gates]</description></item><item><title>Linked List</title><link>https://mohkale.gitlab.io/brain/20210628054059-linked_list/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054059-linked_list/</guid><description>Is a data structure where each node (element) contains a link to the next node and the [see page 9, list] structure only keeps a pointer to the head of the list. You can use a doubly linked linked-list by having each element store a pointer to its parent element as well.
Table 1: see page 9, [Operations] on linked-lists. Method Description x.</description></item><item><title>Linux</title><link>https://mohkale.gitlab.io/brain/20210915160451-linux/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210915160451-linux/</guid><description>Is a free and open-source kernel.</description></item><item><title>Linux Forensics</title><link>https://mohkale.gitlab.io/brain/20210318010314-linux_forensics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210318010314-linux_forensics/</guid><description>OS Forensics targeting the windows operating system. The [see page 2, best operating system] ever!
Note: Data removed with rm still stays on disk.</description></item><item><title>Liquidity</title><link>https://mohkale.gitlab.io/brain/20201021175612-liquidity/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021175612-liquidity/</guid><description>Measures the short term mobility of the company to pay its measuring obligations and meet its shortterm needs for cash. After analysing the different ratios, we produce a [see page 6, liquidity analysis] to determine how profitable an investment in the company could be.
Liquidity Ratio Is often defined using [see page 3, current ratio].
\[ Current Ratio = \frac{Current Assets}{Current Liabilities} \]
A current ratio of 1.76 means for every £1 of liability, the company has £1.</description></item><item><title>Little Omega Notation</title><link>https://mohkale.gitlab.io/brain/20210628051151-little_omega_notation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628051151-little_omega_notation/</guid><description>An asymptotic function which indicates strictly [see page 15, faster] growth.
\begin{align*} f(n) = o(g(n)) \text{\; if \;} g(n) = o(f(n)) \end{align*}</description></item><item><title>Little-O Notation</title><link>https://mohkale.gitlab.io/brain/20210628051049-little_o_notation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628051049-little_o_notation/</guid><description>An asymptotic function which indicates strictly [see page 15, slower] growth.
\begin{align*} f(n) = o(g(n)) \text{\; if \;} \lim_{n \rightarrow \infty} \frac{f(n)}{g(n)} = 0 \end{align*}</description></item><item><title>LMS-Algorithm</title><link>https://mohkale.gitlab.io/brain/20210107213153-lms_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210107213153-lms_algorithm/</guid><description>Is the simplest and most well known Gradient Algorithm.
Given a cost [see page 14, function] this algorithm continually moves in the direction of the negative gradient until it converges towards a minimum.
The drawback with this algorithm is the step-size being difficult to calculate. It can be a value in the range from 0 to some value related to $&amp;lambda;\text{max}\ (the maximum eigenvalue of the auto-correlation matrix \(R_{xx}\) (which changes with each weight calculation))</description></item><item><title>Load Balancer</title><link>https://mohkale.gitlab.io/brain/20201127024626-load_balancer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127024626-load_balancer/</guid><description>A load balancer is a reverse-proxy which acts as a front for s distributed-system. Requests go into the load balancer and can be sent through multiple servers or databases and then returned to the correct client.
Load balancers are often setup as active-active systems and can be usefule for:
Preventing requests from going to unhealthy servers Preventing overloading resources Helping to eliminate a single point of failure (of-course you'll need multiple load balancers to avoid the balancer becoming the SPOF).</description></item><item><title>Loans</title><link>https://mohkale.gitlab.io/brain/20210110054330-loans/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110054330-loans/</guid><description>A quick [see page 9, investment] which needs to be re-payed, often at a high interest rate.
We normally call the original amount of sum borrowed the principal.
Loans will often require a security (eg. your house, or other long term investment).
A term loan is a loan offered by banks that fixes an amount time period repayment terms and interest rates are negotiated and repayed.
A loan-note/bond (eg. Eurobonds) represents a promise to pay a certain amount of money at a certain maturity date + a certain interest rate on the initial input.</description></item><item><title>Localhost</title><link>https://mohkale.gitlab.io/brain/20210719192558-localhost/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719192558-localhost/</guid><description>Is a special host-name always referencing the current machine.</description></item><item><title>Locality</title><link>https://mohkale.gitlab.io/brain/20210718002313-locality/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718002313-locality/</guid><description>Is a property of memory access where memory reads/writes that're close together in time tend to cluster in memory space.
This is the reason virtual memory is so effective. Without it you'd have to do a disk read/write every time you try to reach a new reference making virtual memory as slow as disk. However because programs demonstrate strong locality your OS can do relatively few swaps per read. The actual swapping algorithm uses a basic LRU cache with blocks being swapped into memory as their needed and when physical memory for the working set is running low it swaps the least-recently-used block out.</description></item><item><title>Locus</title><link>https://mohkale.gitlab.io/brain/20210622000530-locus/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622000530-locus/</guid><description>For two variables, \( A,B \) and a point \( P = (x,y) \) dependent on them, we define the locus of P as the set of points which P covers/forms when A and B are being moved/varied while still satisfying some condition which we established at the start of the problem statement.</description></item><item><title>Logarithms</title><link>https://mohkale.gitlab.io/brain/20210621184217-logarithms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621184217-logarithms/</guid><description>If some number \( a \) to the power \( x \) is \( y \), \( a^x = y \), then log to the base \( a \) of \( y \) is \( x \): \( \log_a y = x \), and equivalently \[ e^{x \ln a} = a^x \]
This can be proved through the opposite approach. Consider an equation \( \log_a x = y \), we can raise both the left and right hand sides of this by \( a \) to get \( a^{\log_a x} = a^y \).</description></item><item><title>Logical Block Addressing</title><link>https://mohkale.gitlab.io/brain/20210814000001-logical_block_addressing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210814000001-logical_block_addressing/</guid><description>TODO: https://en.wikipedia.org/wiki/Logical_block_addressing</description></item><item><title>Logical Constraints</title><link>https://mohkale.gitlab.io/brain/20210906005953-logical_constraints/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906005953-logical_constraints/</guid><description>Constraints related to logistical features of the system:
Are we dealing with small or large amounts of data? What modules will be built? Ease of update, maintenance? How will it be packaged and deployed? Over different hardware?</description></item><item><title>Logistic AI</title><link>https://mohkale.gitlab.io/brain/20210926211905-logistic_ai/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926211905-logistic_ai/</guid><description>Is a traditional field within AI that hopes to build on programs of logic (theorem provers, deductive algorithms, etc.) to create intelligent systems.
The main obstacles to this approach are:
It's not easy to take informal knowledge and formulate it in terms required by logical notation (particularly when the knowledge isn't 100% certain). There is a big difference between solving a problem in principle and in practice. Even a problem with a few hundred facts could exhaust a computer resources and require guidance to solve it in an acceptable amount of time.</description></item><item><title>London Stock Exchange</title><link>https://mohkale.gitlab.io/brain/20210110062249-london_stock_exchange/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110062249-london_stock_exchange/</guid><description>Allows the [see page 18, trading] of quoted companies (includes UK based companies and foreign companies which have a quotation in the UK) shares and government and company bonds.
Operates as both primary and secondary market.
primary - Enables new entrants to apply for a listing and if successfully float on the market. Allows companies to apply for more shares to increase revenue. secondary - Allows investors to easily buy and sell securities (eg.</description></item><item><title>Long Term Scheduling</title><link>https://mohkale.gitlab.io/brain/20211009132824-long_term_scheduling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009132824-long_term_scheduling/</guid><description>Are gatekeepers for processes. When a process requests another process to be executed the long term scheduler will either tell the process yes, no or wait.</description></item><item><title>Loop Invariant</title><link>https://mohkale.gitlab.io/brain/20210628051440-loop_invariant/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628051440-loop_invariant/</guid><description>Is a inductive approach to [see page 14, proving] the correctness of algorithms with loops. A loop invariant is a statement that is always true and reflects the progress of the algorithm towards producing a correct output.
The proof process is establishing the invariant is true at:
Initialisation: The invariant holds before the algorithm has done anything. Maintenance: Show that if the invariant holds for \( i \) iterations then it also holds after the \( i+1^{\text{th}} \) iteration.</description></item><item><title>Low Level Animation</title><link>https://mohkale.gitlab.io/brain/20201124163551-low_level_animation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201124163551-low_level_animation/</guid><description>[see page 6, Low] level animation has a lot of parameters and can animate an object without knowledge of the causation behind the animation.
Barr's deformation parameters A [see page 16, form of deformation] where we alter one (or more) parameters subject to the variation of another parameter.
Free Form Deformation We define a bezier (space/container) patches around an object and then distort the container. This approaches major advantages is that is can work independent of the object representation.</description></item><item><title>LRU Cache</title><link>https://mohkale.gitlab.io/brain/20210718004400-lru_cache/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718004400-lru_cache/</guid><description>Is an algorithm for caching access, with the least recently used cache entry being removed from the cache when it's memory size is exceeded.</description></item><item><title>Machine Language</title><link>https://mohkale.gitlab.io/brain/20220102165559-machine_language/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220102165559-machine_language/</guid><description>The lowest-level and oldest class of programming languages. Instructions were written in 0s and 1s that explicitly told the computer which instructions to run and in what order.</description></item><item><title>Main Memory</title><link>https://mohkale.gitlab.io/brain/20210717215203-main_memory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717215203-main_memory/</guid><description>Refer to a main volatile memory store, such as RAM.</description></item><item><title>Make or Buy</title><link>https://mohkale.gitlab.io/brain/20201114231726-make_or_buy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114231726-make_or_buy/</guid><description>A decision for when a component can be [see page 31, manufactured-or-bought].
.org-center { margin-left: auto; margin-right: auto; text-align: center; } If there is surplus capacity, then variable costs of manufacture should be compared with purchase price. See [see page 32, example]. Note: We disregard fixed overheads because for short term decisions they occur in both make or buy scenarios.</description></item><item><title>Malleus, Incus, Stapes</title><link>https://mohkale.gitlab.io/brain/20210129012049-malleus_incus_stapes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129012049-malleus_incus_stapes/</guid><description>Are three small bones positioned after the eardrum which amplifies incoming sound.
These three bones are collectively referred to as the [see page 4, ossicles].
It transmits the energy intersecting the large area ear drum through the small-area Oval window causing the sound to be amplified due to the [see page 5, increased pressure]. There're muscles around these bones which contract around large sounds to suppress extremely loud sounds.</description></item><item><title>Malware</title><link>https://mohkale.gitlab.io/brain/20210212002718-malware/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210212002718-malware/</guid><description>Unauthorised software on a client computer/server which is used for attack.
Malware can capture keyboard, mouse or screen output which can then be parsed to find login credentials.</description></item><item><title>man</title><link>https://mohkale.gitlab.io/brain/20211001154018-man/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211001154018-man/</guid><description>Is the builtin linux manual. See man.</description></item><item><title>Man in the Middle Attack</title><link>https://mohkale.gitlab.io/brain/20210429002924-man_in_the_middle_attack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429002924-man_in_the_middle_attack/</guid><description>Is a security attack on a communication channel by an attacker mediating the communications between a sender and a receiver.</description></item><item><title>Mandatory Access Control</title><link>https://mohkale.gitlab.io/brain/20210211230047-mandatory_access_control/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211230047-mandatory_access_control/</guid><description>An access control system which [see page 9, associates] subjects and objects with special security attributes (classes) which are used as the basis for subject-access-object decisions.
Note: changing these attributes/classes is tightly controlled and rarely done.
Bell La Padula Each object (file) in a MAC system is assigned a class indicating their sensitivity. Subjects (users/processes) are assigned a see page 17, clearance.
[see page 19, No Read Up] .org-center { margin-left: auto; margin-right: auto; text-align: center; } A subject may only read objects at or below its clearance.</description></item><item><title>Margin of Safety</title><link>https://mohkale.gitlab.io/brain/20210110023417-margin_of_safety/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110023417-margin_of_safety/</guid><description>The expected extra intended [see page 16, profit] from planned (or actual) sales above the break-even-point.
Essentially how many units we need to reach out target profit. This is often presented as a fraction of the excess units and the total number of units.</description></item><item><title>Marginal Cost</title><link>https://mohkale.gitlab.io/brain/20201114223418-marginal_cost/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114223418-marginal_cost/</guid><description>The cost of one additional unit of a product or service. The cost of an additional unit is the cost that change.</description></item><item><title>Marginal Costing</title><link>https://mohkale.gitlab.io/brain/20201106014500-marginal_costing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106014500-marginal_costing/</guid><description>A [see page 16, markup-calculation] process which takes into account the direct-cost and Variable Costs.
See example [see page 25, here] and [see page 17, here].
Marginal costing judges a project based on its contribution-margin. A project will be accepted if it makes a +ve contribution (contributes to reducing fixed costs or produces a profit for the business).
If the contribution margin of a special-order produces a net-positive profit, it should be accepted.</description></item><item><title>Market Price</title><link>https://mohkale.gitlab.io/brain/20201106012716-market_price/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106012716-market_price/</guid><description>The current price at which a product can be bought or sold.</description></item><item><title>Market Theory</title><link>https://mohkale.gitlab.io/brain/20201106012746-market_theory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106012746-market_theory/</guid><description>Prices high -&amp;gt; more supplies.
Suppliers produce more. More suppliers enter business.</description></item><item><title>Markovian Decision Process</title><link>https://mohkale.gitlab.io/brain/20210530035044-markovian_decision_process/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210530035044-markovian_decision_process/</guid><description>A decision process [see page 5, where] the probability of transitioning to the next state depends only on the current state and not the whole previous history. These decision problems stick closely to the markovian property.
Markovian Property Restates the description of a markov-decision-process mathematically.
\begin{align} \label{eq:markov-prop} P({S}_{t+1} {r}_{t+1} | {s}_{t}, {a}_{t}, {r}_{t}, {s}_{t-1}, {a}_{t-1}, {r}_{t-1}) = P({s}_{t+1}, {r}_{t+1} | {s}_{t}, {a}_{t}) \end{align}</description></item><item><title>Masking</title><link>https://mohkale.gitlab.io/brain/20210129022547-masking/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129022547-masking/</guid><description>Is the affect where weaker (low frequency) signals can be made inaudible by stronger (high frequency) signals. I.E a frequency when heard raises the threshold of hearing to the point where a second tone can be made inaudible (see [see page 13, here]).
This is due to the overlap between auditory filters.
We define critical band the bandwidth over which masking operates
We use a [see page 14, spreading function] to determine the affect of a large tone on the hearing threshold, with the MP3 one being designed from hearing tests.</description></item><item><title>Master Boot Record</title><link>https://mohkale.gitlab.io/brain/20210811031413-master_boot_record/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811031413-master_boot_record/</guid><description>Is the first 512 bytes (beginning from physical offset 0) of a storage device, preceding the first disk partition.
The master boot record stores the storage-devices partition table and can use its first 440 bytes to contain an OS boot-loader. The MBR scheme limits the size of a partition entry to 32-bits meaning the maximum addressable storage space of a partitioned disk, using the MBR system and assuming 512-byte sectors, is 2-TiB (\( 2^{32} \times 512 \text{bytes} \)).</description></item><item><title>Matching</title><link>https://mohkale.gitlab.io/brain/20210622185138-matching/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622185138-matching/</guid><description>Is a sub-graph of a bipartite graph such that none of the chosen edges have a common vertex.
\begin{figure} \centering \begin{tikzpicture} \node (l1) [draw, circle] {}; \node (r1) [draw, circle, right=of l1] {}; \node (l2) [draw, circle, below=of l1] {}; \node (r2) [draw, circle, below=of r1, right=of l2] {}; \node (l3) [draw, circle, below=of l2] {}; \node (r3) [draw, circle, below=of r2, right=of l3] {}; \node (l4) [draw, circle, below=of l3] {}; \node (r4) [draw, circle, below=of r3, right=of l4] {}; \node (l5) [draw, circle, below=of l4] {}; \node (r5) [draw, circle, below=of r4, right=of l5] {}; \draw [color=red] (l1) -- (r1) (l2) -- (r3) (l4) -- (r5); \draw [color=black!</description></item><item><title>Matrix</title><link>https://mohkale.gitlab.io/brain/20210621220257-matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621220257-matrix/</guid><description>A Matrix is a rectangular array of numbers, such as \( \begin{pmatrix} 1 &amp;amp; 2 \\ 3 &amp;amp; 4\end{pmatrix} \).
Arithmetic Operations Addition and subtraction of two matrices is an element-wise operation and can only be done when both matrices shares the same shape. Multiplying or dividing by a scalar applies the multiplication to all the elements of the matrix.
The key operation when working with matrices is multiplication between two matrices.</description></item><item><title>Matrix Transformations</title><link>https://mohkale.gitlab.io/brain/20210621224123-matrix_transformations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621224123-matrix_transformations/</guid><description>Applying a matrix to a vector (or collection of vectors) is the same as applying a transformation to those vectors. Warn: Matrix multiplication can only do rotation, reflection, shear &amp;amp; stretch transformations.
For example if he have the points \( (1,0)^T \) and \( (0,1)^T \) and the matrix \( \begin{pmatrix} 3 &amp;amp; 0 \\ 0 &amp;amp; 3 \end{pmatrix} \), then
\begin{align*} \begin{pmatrix}
3 &amp;amp; 0 \\\\ 0 &amp;amp; 3 \end{pmatrix}</description></item><item><title>Max Heap</title><link>https://mohkale.gitlab.io/brain/20210628052809-max_heap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628052809-max_heap/</guid><description>A heap with the max-heap property:
For every node \( n \) (other than the root) the value of that node is no-greater than its parent. \[ \forall i \in N A[\text{Parent}(n)] \geq A[n] \]
From this it follows that the root-node of a max-heap is the largest element of the heap.
def max_heapify(arr, i): l = left(i) r = right(i) # Pick the larger of the current node # or left and right sub-node.</description></item><item><title>Max-Heap Sort</title><link>https://mohkale.gitlab.io/brain/20210628052840-max_heap_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628052840-max_heap_sort/</guid><description>Is a in-place sorting algorithm taking advantage of the properties of a max-heap.
def heap_sort(arr): build_max_heap(arr) for i in reversed(range(1, len(arr))): swap(arr, 0, i) arr.length -= 1 max_heapify(arr, 0) Code Snippet 1: Heap sort implementation. alg:heap_sort Heap sort can be seen in alg:heap_sort. Heap-sort [see page 17, works] by constructing a heap from the collection, swapping the first value of the heap (the largest value in the array by the max-heap property) and the end of the array, then shrinking the perceived size of the array by one and re-establishing the max-heap property by calling build_max_heap on the root.</description></item><item><title>Maximal Matching</title><link>https://mohkale.gitlab.io/brain/20210622185635-maximal_matching/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622185635-maximal_matching/</guid><description>Is a matching in which the number of edges is as large as possible.
\begin{figure} \centering \begin{tikzpicture} \node (l1) [draw, circle] {}; \node (r1) [draw, circle, right=of l1] {}; \node (l2) [draw, circle, below=of l1] {}; \node (r2) [draw, circle, below=of r1, right=of l2] {}; \node (l3) [draw, circle, below=of l2] {}; \node (r3) [draw, circle, below=of r2, right=of l3] {}; \node (l4) [draw, circle, below=of l3] {}; \node (r4) [draw, circle, below=of r3, right=of l4] {}; \node (l5) [draw, circle, below=of l4] {}; \node (r5) [draw, circle, below=of r4, right=of l5] {}; \node [left=of l4] {A}; \node [left=of l5] {B}; \node [right=of r5] {C}; \draw [color=red] (l1) -- (r1) (l2) -- (r2) (l3) -- (r3) (l4) -- (r5); \draw [color=black!</description></item><item><title>McCabe Metrics</title><link>https://mohkale.gitlab.io/brain/20210626235027-mccabe_metrics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626235027-mccabe_metrics/</guid><description>A code metric that interprets the [see page 44, control flow] graph of a procedure to measure its complexity.
This involves identifying where the procedure branches (while loops, conditions, etc.), generally whenever the code is indented, to form a graph and then using a measure of the edges of the graph to state its complexity.</description></item><item><title>Meatus</title><link>https://mohkale.gitlab.io/brain/20210129012344-meatus/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129012344-meatus/</guid><description>A [see page 4, tube] leading from the pinna to the middle of the ear.
The meatus terminates at the cone shaped tympanic membrane (eardrum).</description></item><item><title>Mediator Pattern</title><link>https://mohkale.gitlab.io/brain/20210922044255-mediator_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922044255-mediator_pattern/</guid><description>Is a software design pattern where an object mediates the communication between many other objects, eliminating the need for direct coupling between communicating objects. For example a loan oversees the relationship between a borrower and a book.
This pattern decouples objects from each other [see page 24, indicating] loose coupling.</description></item><item><title>Medium Level Animation</title><link>https://mohkale.gitlab.io/brain/20201124185415-medium_level_animation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201124185415-medium_level_animation/</guid><description>An [see page 25, animation] approach where we give a few parameters which then get processed into many parameters which then affect the objects in the scene.
Particle Systems A particle system could have million of particles each with their own state (position, velocity, radius, etc.). Storing each of these for each frame is intractable so we instead [see page 26, specify] a few values (direction, initial velocity, etc.) and [see page 27, apply] some randomness to each particle at it's creation.</description></item><item><title>Medium Term Scheduling</title><link>https://mohkale.gitlab.io/brain/20211009133227-medium_term_scheduling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009133227-medium_term_scheduling/</guid><description>Is a scheduler that deals with moving a process from the paused state in memory to the paused state on the disk when there are too many processes or some are known to use an insignificant amount of CPU cycles (consider a process that only checks somethings once an hour).</description></item><item><title>Mel Frequency</title><link>https://mohkale.gitlab.io/brain/20210108021527-mel_frequency/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210108021527-mel_frequency/</guid><description>Is a non-linear [see page 8, frequency scale] tied to auditory pitch perception.
It's approximately linear up-to 1KHz but then logarithmic.
One of the consequences of the Mel-scale is that rather than rectangular filters we [see page 8, use] half-overlapping triangular filters 🙂.
The name derives from the word melody.</description></item><item><title>Memoization</title><link>https://mohkale.gitlab.io/brain/20210628054749-memoization/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054749-memoization/</guid><description>The process of storing the result of expensive procedure calls for later re-use. This is closely tied to dynamic programming.</description></item><item><title>Memory</title><link>https://mohkale.gitlab.io/brain/20210717195244-memory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717195244-memory/</guid><description>Refers to the various storage mechanisms on a computer.
Table 1: Listing of the main kinds of memory and the average size and read/write rate of it for an average machine in the year 2000. Ordered from fastest to slowest (incidentally also most to least expensive). Memory Size (bytes) Access Rate (bytes/sec) Processor Registers \( 28 \) \( 1 \times 10^9 \) Internal Cache \( 32 \times 10^3 \) \( 500 \times 10^6 \) External Cache \( 512 \times 10^3 \) \( 250 \times 10^6 \) Main Memory \( 256 \times 10^6 \) \( 100 \times 10^6 \) Disk Memory \( 13 \times 10^9 \) \( 100 \times 10^3 \) In the old days processes had direct access to memory.</description></item><item><title>Memory Allocation</title><link>https://mohkale.gitlab.io/brain/20211002221435-memory_allocation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002221435-memory_allocation/</guid><description>Is the process of allocating and managing more memory from the heap at runtime. So called memory-allocators oversee the role of memory allocation including management of memory retrieved from the OS and re-purposing freed memory for newer allocations. They must track which bytes are currently allocated and which are available for use.
void* malloc(size_t size) { // Ask the system for more bytes by extending the heap space. // sbrk returns -1 on failure void *p = sbrk(size); if (p == (void *) -1) return NULL; // No space left return p; } void free() { /* Do nothing */ } Code Snippet 1: A rudimentary malloc implementation that only fetches more memmory and never frees anything.</description></item><item><title>Memory Management</title><link>https://mohkale.gitlab.io/brain/20210717193633-memory_management/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717193633-memory_management/</guid><description>Is the kernel task of ensuring each processes working memory space is distinct from other processes.
The kernel often maintains a table of data and code segments which is updated whenever the process either requests or releases memory. This table is used to configure the MMU to ensure it works correctly.</description></item><item><title>Memory Safety</title><link>https://mohkale.gitlab.io/brain/20210607030335-memory_safety/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607030335-memory_safety/</guid><description>TODO: (NO_ITEM_DATA:com3501-w11-security-testing:32)
Bibliography NO_ITEM_DATA:com3501-w11-security-testing:32</description></item><item><title>Memory Translation</title><link>https://mohkale.gitlab.io/brain/20211008232443-memory_translation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008232443-memory_translation/</guid><description>Is the process of converting a virtual memory address into a physical memory address. It acts as a translation layer between the address as known by the process and the actual address on the hardware. The outline for how this works is:
A process makes a memory request. The circuit checks the translation lookaside buffer for a cached address. The memory management unit: Performs the address translation, Pulls the address from RAM, and Caches the result into the TLB.</description></item><item><title>Merge Sort</title><link>https://mohkale.gitlab.io/brain/20210628052308-merge_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628052308-merge_sort/</guid><description>A divide &amp;amp; conquer sorting algorithm with runtime-page 12, [complexity](com1009-l03-divide-and-conquer) \( \theta(n \log n) \).
It [see page 4, works] by:
Divide: the \( n \)-element sequence to be sorted into 2 sub-sequences of \( \frac{n}{2} \) elements. Conquer: sort the two sub-sequences recursively using merge-sort. Combine: merge the two sub-sequences back together to produce the sorted answer. Formulation def merge_sort(arr): if len(arr) &amp;lt;= 1: return mid = len(arr) // 2 l, r = arr[:mid][:], arr[mid:][:] merge_sort(l) merge_sort(r) # Sort the elements in the range.</description></item><item><title>Metric Pairwise K-Means Clustering</title><link>https://mohkale.gitlab.io/brain/20210306205702-metric_pairwise_k_means_clustering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210306205702-metric_pairwise_k_means_clustering/</guid><description>A variant of pairwise K-means clustering which works by [see page 3, warping] the data-space to minimise the separation within clusters and maximise the separation of clusters.
Formulation \begin{align} |{x}^{\mu} - {m}_{k}|^2_w = ({x}^{\mu} - {m}_{k})^{T} W ({x}^{\mu} - {m}_{k}) \end{align}
Where \(W\) is a matrix which shrinks or expands each dimension of the input data to clearly separate clusters.
With this we define our new [see page 5, objective error function], with added constraints, as:</description></item><item><title>Microphone</title><link>https://mohkale.gitlab.io/brain/20201026234326-microphone/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026234326-microphone/</guid><description>[see page 6, Convert] transduce acoustic energy (sound) into electrical energy signals.
These come in two forms:
Kind Description Dynamic Use a moving coil to produce current through EM induction. Condensor Based on a capacitor.</description></item><item><title>Microservice</title><link>https://mohkale.gitlab.io/brain/20201129143959-microservice/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201129143959-microservice/</guid><description>Describes as a suite of independently deployable, small, modular services. Each service runs a unique process and communicates through a well-defined, lightweight mechanism to serve a business goal.</description></item><item><title>Min Heap</title><link>https://mohkale.gitlab.io/brain/20210628053140-min_heap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053140-min_heap/</guid><description>A heap with the min heap property:
For every node \( n \) (other than the root) the value of that node is no smaller than its parent. \[ \forall i \in N A[\text{Parent}(n)] \leq A[n] \]
From this it follows that the root-node of a min-heap is the smallest element of the heap.
The procedure and workflow of a min-heap works much like a max-heap.</description></item><item><title>Min-Max Transformation</title><link>https://mohkale.gitlab.io/brain/20210216035600-min_max_transformation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216035600-min_max_transformation/</guid><description>Is a form of data normalisation where we subtract the minimum value from each point and then divide by the range of possible values.
This moves the data into a range of 0-1 in each dimension (axis).</description></item><item><title>Mini-Batch Gradient Descent</title><link>https://mohkale.gitlab.io/brain/20210305025743-mini_batch_gradient_descent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210305025743-mini_batch_gradient_descent/</guid><description>A variant of gradient descent where the size of the batches is greater than one but less than the number of samples in the training set.</description></item><item><title>Minimal Hebbian Rule</title><link>https://mohkale.gitlab.io/brain/20210218015921-minimal_hebbian_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210218015921-minimal_hebbian_rule/</guid><description>Is the [see page 12, quintessential] hebbian rule based around Hebbs postulum.
\begin{align} \Delta{w_{ij}} = \alpha v_i^{\text{post}} v_j^{\text{pre}} \end{align}
Which states that the weight of a synaptic connection between a pre-synaptic neuron \( j \) and a post-synaptic neuron \( i \) should be proportional to the product of both neurons output-potential. \( \alpha \) in the above equation is some non-negative constant and is used as a learning-rate.
Note By this minimalist definition we only change the weights for a neuron when both its input neuron and itself is firing.</description></item><item><title>Minimal Pairs</title><link>https://mohkale.gitlab.io/brain/20210129224847-minimal_pairs/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129224847-minimal_pairs/</guid><description>A single phoneme in two words at the same position which when changed can [see page 2, alter] the meaning of the word.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } To be a minimal-pair we must have a pair of words that differ in only one segment, where the segment is in the same position in each word and the two words have different meanings (not alternative pronunciations). For example in the words fussy and fuzzy, [s] and [z] are phoneme.</description></item><item><title>Minimum Spanning Tree</title><link>https://mohkale.gitlab.io/brain/20210622174719-minimum_spanning_tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174719-minimum_spanning_tree/</guid><description>A spanning tree where the sum of the length of its edges is as small as possible.</description></item><item><title>Mipmaps</title><link>https://mohkale.gitlab.io/brain/20201105162606-mipmaps/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201105162606-mipmaps/</guid><description>A collection of texture-images where each subsequent texture is half as large as the previous one. This allows the same texture to be used across multiple objects at different distances (providing a much nicer sampling than using one large texture).
We can specify the texture-filtering for mipmaps as well.
Kind Meaning GL_NEAREST_MIPMAP_NEAREST Nearest mipmap level, with nearest neighbor interpolation. GL_LINEAR_MIPMAP_NEAREST Nearest mipmap level, with linear interpolation.</description></item><item><title>mmap</title><link>https://mohkale.gitlab.io/brain/20211009003710-mmap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009003710-mmap/</guid><description>Is a system-call that allows you map pages into memory and share them with child processes. The memory for this could come from a file stored on a disk or from a shared or typed memory object. See mmap and munmap.
// Open the file to mmap. int fd = open(argv[1], O_RDWR); // Stat it to get its file size. size_t length; struct stat sb; fstat(fd, &amp;amp;sb); // Must be a multiple of the page size for the system.</description></item><item><title>MMU</title><link>https://mohkale.gitlab.io/brain/20210718005508-mmu/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718005508-mmu/</guid><description>Is a chip, commonly built directly into the CPU, that puts fences around areas of memory to ensure out of bound references will be refused (by throwing an interrupt).
The general algorithm for the MMU is:
Receive address. Try to translate address according to programmed scheme. If the translation fails report an invalid address. Otherwise If the TLB contains the physical memory, get the frame from the TLB and then perform read/write on it.</description></item><item><title>Mobile Forensics</title><link>https://mohkale.gitlab.io/brain/20210317182824-mobile_forensics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210317182824-mobile_forensics/</guid><description>Variant of digital forensics targeting mobile devices specifically.
This is [see page 4, important] because the number of smartphone users has been increasing for years and its [see page 5, application] in criminal activities has seen similar growth. Even without this, smartphones track an absurd amount of [see page 9, data] about its users and this data can be used to implicate an individual in a crime.
There're also concerns surrounding BYOD (bring your own device) policies which let individuals use their own mobile devices to access confidential information such as documents and emails related to organisations.</description></item><item><title>Mode, Median, Modal</title><link>https://mohkale.gitlab.io/brain/20210622165134-mean_modal_median/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622165134-mean_modal_median/</guid><description>Are common measures of the location and spread of data.
The mean is the average of the set: \( \bar{x} = \frac{1}{n} \sum^n_i x_i \) The modal is the value that appears the most often in the set. The median is the value at the middle of the distribution after sorting.</description></item><item><title>Model-Delegate</title><link>https://mohkale.gitlab.io/brain/20210906025123-model_delegate/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906025123-model_delegate/</guid><description>A transform centre architecture for graphical user interfaces.
\begin{figure} \centering \begin{tikzpicture}[line/.style={very thick}] \begin{umlpackage}{Presentation Layer} \begin{umlpackage}{java/awt}\end{umlpackage} \begin{umlpackage}[below=of java/awt]{javax/swing}\end{umlpackage} \umlsimpleclass[right=1cm of java/awt]{MyListener}; \umlsimpleclass[below=1.75cm of MyListener]{MyFrame}; \end{umlpackage} \begin{umlpackage}[right=3cm]{Application Layer}\end{umlpackage} \draw [line, dashed, -&amp;gt;] (MyListener) -- (java/awt); \draw [line, dashed, -&amp;gt;] (MyFrame) -- (javax/swing); \draw [line, dashed, -&amp;gt;] (Application Layer) -- (MyListener); \draw [line, -&amp;gt;] (MyFrame) -- (MyListener); \draw [line, dashed, -&amp;gt;] (MyFrame.east) -- (Application Layer.south); %(Application Layer.south); \end{tikzpicture} \caption{Model delegate diagram.} \end{figure}</description></item><item><title>Model-View-Controller</title><link>https://mohkale.gitlab.io/brain/20210906024102-model_view_controller/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906024102-model_view_controller/</guid><description>A transform centre architecture for graphical user interfaces.
\begin{figure} \begin{tikzpicture}[line/.style={very thick, dashed}] \begin{umlpackage}{Model}\end{umlpackage} \begin{umlpackage}[x=4, y=-2]{Controller}\end{umlpackage} \begin{umlpackage}[y=-4]{View}\end{umlpackage} \draw [line, &amp;lt;-&amp;gt;] (Controller) -- (Model); \draw [line, &amp;lt;-&amp;gt;] (Controller) -- (View); \end{tikzpicture} \caption{MVC visualised} \end{figure} Table 1: Division of labour. MVC Description Model Objects that model the business domain. View GUI objects that display views and detect events. Controller Event handlers that synchronise views and model data.</description></item><item><title>Modular Arithmetic</title><link>https://mohkale.gitlab.io/brain/20210826012817-modular_arithmetic/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210826012817-modular_arithmetic/</guid><description>When a number \( A \) is divided by another number \( B \) we get an integer quotient \( Q \) and a remainder \( R \). Modular arithmetic is a system of arithmetic numbers concerned only with the remainder of an expression.
\begin{align} \frac{A}{B} &amp;amp;= Q \; \text{remainder} \; R \
A \mod B &amp;amp;= R \label{eq:mod-remainder} \end{align}
Modulo The modulo operator, \( \mod \), asserts that the result of the expression is equivalent to some arbitrary multiple of the modulus \( B \) plus \( R \).</description></item><item><title>Modular Protection</title><link>https://mohkale.gitlab.io/brain/20210924030648-modular_protection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210924030648-modular_protection/</guid><description>Is a concept of a class preventing unauthorised modification.</description></item><item><title>Modulus</title><link>https://mohkale.gitlab.io/brain/20210826013822-modulus/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210826013822-modulus/</guid><description>Is the number in modular arithmetic where the sequence wraps around. In the statement \( A \mod B = X \) the modulus is \( B \).</description></item><item><title>Modulus Function</title><link>https://mohkale.gitlab.io/brain/20210621215843-modulus_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621215843-modulus_function/</guid><description>A special function which returns the absolute value of its arguments.
\begin{align} \abs{x} &amp;amp;= \begin{cases}
+x, \qquad \text{if \\( x \geq 0 \\)} \\\\ -x, \qquad \text{if \\( x &amp;lt; 0 \\)} \end{cases} \end{align}</description></item><item><title>Moire Patterns</title><link>https://mohkale.gitlab.io/brain/20201109160320-moire_patterns/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109160320-moire_patterns/</guid><description>An [see page 5, issue] with repeating textures and the coherence of the pattern breaking up when the sampling density of the screen comes close to the density of the actual pattern.</description></item><item><title>Mono-alphabetic Substitution Cipher</title><link>https://mohkale.gitlab.io/brain/20210215021940-mono_alphabetic_substitution_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215021940-mono_alphabetic_substitution_cipher/</guid><description>A substitution cipher in which each letter corresponds to one letter of the normal alphabet, and encrypting a string of letters with a key is the same as encrypting each individual letter independently.
\begin{align*} E_e (m) &amp;amp;= e(m_1) e(m_2) e(m_3) \ldots e(m_n) = c_1 c_2 c_3 \ldots c_n = c \
D_d ( c) &amp;amp;= d(c_1) d(c_2) d(c_3) \ldots d(c_n) = m \
\end{align*}</description></item><item><title>Monopthongs</title><link>https://mohkale.gitlab.io/brain/20210129064144-monopthongs/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129064144-monopthongs/</guid><description>A vowel that has a single perceived auditory quality.</description></item><item><title>Monotonic Function</title><link>https://mohkale.gitlab.io/brain/20210621190207-monotonic_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621190207-monotonic_function/</guid><description>A Monotonic (increasing) functions is one where the value of \( y \) is increasing as we increase \( x \). A Non-Monotonic (decreasing) function is one where the value of \( y \) decreases as we increase \( x \). Some functions display both increasing and decreasing behaviour as \( x \) changes.
\begin{figure} \centering \begin{tikzpicture} \begin{axis}[axis lines=center, xmin=-10, xmax=10, ymin=-5, ymax=5, domain=-5:5] \addplot[color=red]{2^x};, \addplot[color=blue]{2^(-x)};, \addplot[color=green]{x^3 + 3*x^2};, \end{axis} \end{tikzpicture} \caption{Demonstration of an increasing (red), decreasing (blue) and an increasing, decreasing, then increasing (green) function.</description></item><item><title>Moral Rights</title><link>https://mohkale.gitlab.io/brain/20201023235432-moral_rights/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023235432-moral_rights/</guid><description>Rights an author can maintain even after selling copyright has been given/sold to another party.
See [see page 14, here].</description></item><item><title>Mosaicing</title><link>https://mohkale.gitlab.io/brain/20201104221544-mosaicing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201104221544-mosaicing/</guid><description>Combining pieces of art to show various component parts of the invention were known and thus the invention is not new.</description></item><item><title>MOSCOW Method</title><link>https://mohkale.gitlab.io/brain/20210626233831-moscow_method/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626233831-moscow_method/</guid><description>Is a way to prioritise requirements in requirements analysis. It [see page 27, consists] of:
Must: Required features. Should: Important features. Could: Desirable features. Won't: Optional features.</description></item><item><title>Most Vexing Parse</title><link>https://mohkale.gitlab.io/brain/20220228141029-most_vexing_parse/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220228141029-most_vexing_parse/</guid><description>Is a parsing problem for C++ code due to the different precedence rules in the parser implementation.
// Is this: // + Declaring a variable foo of type Foo calling a constructor taking // a single argument of a newly default-constructed Bar object. // + A function declaration. &amp;lt;- Hint: Yes, it&amp;#39;s this, WHAT? 😕. Foo foo(Bar());</description></item><item><title>Motherboard</title><link>https://mohkale.gitlab.io/brain/20210717015933-motherboard/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717015933-motherboard/</guid><description>Is the main circuit board for a computer. All other hardware components plug into the motherboard including any peripheral devices, the CPU, dedicated GPUs, etc.</description></item><item><title>Motion Capture</title><link>https://mohkale.gitlab.io/brain/20201124165256-motion_capture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201124165256-motion_capture/</guid><description>A [see page 23, way] to define an animation by placing markers on a person and having them move, recording changes in position over time.</description></item><item><title>Mount Points</title><link>https://mohkale.gitlab.io/brain/20210718015500-mount_points/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718015500-mount_points/</guid><description>Refers to file systems that are mounted onto some directory entry in your root file system. You can mount files using the mount system-call and then later unmount them.
Mounting Regular Files You can mount a regular file containing a complete file-system by specifying the loop option. This option wraps the original file as a block device.
mkdir arch sudo mount -o loop archlinux-2015.04.01-dual.iso ./arch ls arch Code Snippet 1: Example of mounting an ISO onto a local directory.</description></item><item><title>Moving Weighted Average</title><link>https://mohkale.gitlab.io/brain/20201109161619-moving_weighted_average/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109161619-moving_weighted_average/</guid><description>A way of blurring an image by replacing values in a sequence with the average of a moving window through the sequence.
\[ b_{smooth}[i] = \frac{1}{2r+1} \sum_^{i+r} b[j] \]
We can [see page 11, weight] samples in the sequence to get a more gaussian like affect.</description></item><item><title>Multi Level Security</title><link>https://mohkale.gitlab.io/brain/20210212002958-multi_level_security/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210212002958-multi_level_security/</guid><description>Military security model and its computer system implementation.</description></item><item><title>Multi Sampling</title><link>https://mohkale.gitlab.io/brain/20201109191653-multi_sampling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109191653-multi_sampling/</guid><description>A form of uniform post-filtering which fixes aliasing issues by using a common pattern to sub-sample each pixel.
For [see page 21, MSAA] each pixel is divided into sub-pixels and rendered separately. We then use an average of these sub-samples to determine each pixels colors.
This is like SSAA but rather than rendering at a higher resolution, we pick a certain pattern (non-stochastically) and pick multiple samples at those points for each pixel averaging the result into the final pixel color.</description></item><item><title>Multi-factor Authentication</title><link>https://mohkale.gitlab.io/brain/20210211183430-multi_factor_authentication/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211183430-multi_factor_authentication/</guid><description>A form of authentication which combines one or more authentication methods at the same time to authenticate someone.
eg. I sign in with a password and then am asked to confirm through my phone</description></item><item><title>Multitasking</title><link>https://mohkale.gitlab.io/brain/20210717193106-multitasking/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717193106-multitasking/</guid><description>Refers to an OS that can routinely support many simultaneous processes.
The Unix family of operating systems was designed from the ground up for multitasking and is very good at it. Efficient, reliable multitasking is a large part of what makes Linux superior for networking, communications, and Web service.</description></item><item><title>Mutex</title><link>https://mohkale.gitlab.io/brain/20211004035404-mutex/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211004035404-mutex/</guid><description>Is a synchronisation primitive for threads. It locks a resource such that multiple threads cannot access it simultaneously. If the resource is locked while another thread tries to access it, that thread is blocked until the resource becomes available (I.E. it's relinquished by the thread that locked it).
Note: The thread that locks a MUTEX is the only thread that can unlock it.
// Must be shared visible to all the threads, // perhaps as a global variable.</description></item><item><title>MVP-Matrix</title><link>https://mohkale.gitlab.io/brain/20201107013537-mvp_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201107013537-mvp_matrix/</guid><description>A [see page 19, matrix] used to transition an object from it's local coordinate system to its final position on the screen.
The matrix consists of the:
Matrix Purpose Model Positions/builds the object in world space. Scale, translate, etc. View Transform the object to how it would be seen through your camera. Projection Apply any projection transformations. It's defined as \(mvp = projection * view * model\).</description></item><item><title>N-Ary Relations</title><link>https://mohkale.gitlab.io/brain/20210627011442-n_ary_relations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627011442-n_ary_relations/</guid><description>Is any set of \( n \)-tuples, that can be used to express a [see page 6, relation] between variables. Membership in this set specifies that there exists a relation between the tuple entries. For example if we define a relation between the set of people \( P \) and locations \( L \) we'll get a binary relation (set of tuples of size 2) which is a subset of \( P \times L \).</description></item><item><title>Naive Bayes Classifier</title><link>https://mohkale.gitlab.io/brain/20201125172259-naive_bayes_classifier/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201125172259-naive_bayes_classifier/</guid><description>A bayes-classifier which assumes each feature vector is independent of other vectors. Meaning no covariance is taken into account.
See [see page 39, advantagaes vs. disadvantages] and [see page 40, improvements].</description></item><item><title>Naive Ray Tracing</title><link>https://mohkale.gitlab.io/brain/20210105023659-naive_ray_tracing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210105023659-naive_ray_tracing/</guid><description>A form of ray-tracing which for each incident ray recursively produces one (or more) output rays (that recursively produce more rays when meeting subsequent objects) until some recursive limit is reached.
This [see page 2, only] works between specular to specular light interaction. I.E. reflective surfaces.
See [see page 17, stages] and [see page 29, final-algorithm]. Requires:
Initial ray direction Hidden surface removal Reflected and refracted rays Lighting model Shadows Recursion The number of recursive steps alters the [see page 30, depth] to which reflected surfaces are perceivable.</description></item><item><title>Name Entity Recognition</title><link>https://mohkale.gitlab.io/brain/20201210184600-name_entity_recognition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201210184600-name_entity_recognition/</guid><description>The process of [see page 21, identifying] the extent (and type) of each entity mentioned in a text.
Kinds of entities we're interested in [see page 22, include]:
Entity Examples Named individuals persons, companies, organisations Times temporal expressions, dates and times of day Measures monetary expressions, distances/sizes, weights</description></item><item><title>Name Server</title><link>https://mohkale.gitlab.io/brain/20210719192535-name_server/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719192535-name_server/</guid><description>Is a server associating domain-names with ip-addresses.
Name servers make heavy use of caching, keeping recent IP address lookups in memory for a short period. As a special case if the host is unreachable then the cached IP address is immediately discarded.</description></item><item><title>Natural Frequency</title><link>https://mohkale.gitlab.io/brain/20201115193011-natural_frequency/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201115193011-natural_frequency/</guid><description>The natural frequency that an object will vibrate at when struck, plucked or otherwise given energy.
Note: An object can have multiple natural frequencies.
Consider a goblet of glass. If you stroke your fingers over it's rim it can produce a sound (through slip-stick friction). The sound is caused by the glass molecules vibrating at their natural frequency.</description></item><item><title>Negligence</title><link>https://mohkale.gitlab.io/brain/20201114183546-negligence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114183546-negligence/</guid><description>Negligence (eg. Negligent driver crashing into your car).
For a tort of negligence:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } The defendant is liable for all damage caused by his breach of duty to take reasonable care, provided that the damage is not too remote. Negligence is the [see page 4, [omission](MGT388-law-w08)] to do something which a [see page 5, [reasonable](MGT388-law-w08)] (a typical person with ordinary prudence) man would do or doing something which a prudent and reasonable man would not do (in the circumstances).</description></item><item><title>Net Asset Turnover</title><link>https://mohkale.gitlab.io/brain/20201021170102-net_asset_turnover/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021170102-net_asset_turnover/</guid><description>\[ \frac{Revenue}{Equity + Non-Current Liabilities} \]
A NAT of \(1.67\) means for every pound of investment, \(£1.67\) of turnover (revenue) is generated.
Warn: an investment in assets may not translate to increased revenue immediately.</description></item><item><title>Network Certificate</title><link>https://mohkale.gitlab.io/brain/20210429004358-network_certificate/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429004358-network_certificate/</guid><description>Is a [see page 13, certificate] that is signed by some certifying authorities private key. A client who accesses a site receives the certificate and can compare the signature with the authorities public key to verify the server is who the authority thinks it is.
If the client [see page 17, trusts] the CA and the certificate check (is authenticated, not expired) passes, they consider the sender secure/trustworthy.
Certificate Types We can classify certificates based on the [see page 44, validation] they provide:</description></item><item><title>Network Interface</title><link>https://mohkale.gitlab.io/brain/20211009183026-network_interface/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009183026-network_interface/</guid><description>#include &amp;lt;stdio.h&amp;gt;#include &amp;lt;stdlib.h&amp;gt;#include &amp;lt;sys/socket.h&amp;gt;#include &amp;lt;sys/types.h&amp;gt;#include &amp;lt;netdb.h&amp;gt; int required_family = AF_INET; // Equivalently AF_INET6 is for IPv6 int family_size = (required_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6); struct ifaddrs *myaddrs; getifaddrs(&amp;amp;myaddrs); char host[256], port[256]; struct ifaddrs *ifa; for (ifa = myaddrs; ifa != NULL; ifa = ifa-&amp;gt;next) { // When the address exists and matches the protocol family we&amp;#39;re interested in. if (ifa-&amp;gt;ifa_addr &amp;amp;&amp;amp; ifa-&amp;gt;ifa_addr-&amp;gt;sa_family == required_family) { int ret = getnameinfo(ifa-&amp;gt;ifaaddr, family_size, host, sizeof(host), port, sizeof(port), NI_NUMERICHOST, NI_NUMERICSERV); if (ret == 0) { puts(host); } } } Code Snippet 1: An example program retrieving all network interfaces and then printing the IP address of all of them with IPv4 configurations.</description></item><item><title>Network Protocol</title><link>https://mohkale.gitlab.io/brain/20210428235726-network_protocol/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428235726-network_protocol/</guid><description>Are [see page 9, rules] used to outline the connection creation and data transmission process.
Example protocols include UDP, TCP, etc.</description></item><item><title>Neural Network</title><link>https://mohkale.gitlab.io/brain/20210206060816-neural_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206060816-neural_network/</guid><description>A supervised learning algorithm centred around artificial neurons.
We construct a network of artificial neurons and feed inputs to the first-layer, propagating through subsequent neuron layers until getting an output. Each of the neurons in one layer are connected to all of the neurons in the second layer, and so on and so forth.</description></item><item><title>Neural Spike Rate</title><link>https://mohkale.gitlab.io/brain/20210206065914-neural_spike_rate/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206065914-neural_spike_rate/</guid><description>A measure of the rate of excitation of a neuron over a period of time.
It's [see page 7, defined] as the sum of the change in potential averaged over the measurement interval: \[ v = \frac{n_{sp}(t; t + T)}{T} \] With:
\( n_{sp} \) being the number of spikes over the period \( T \). \( T \) being the duration over which we measured spikes.</description></item><item><title>Neuron</title><link>https://mohkale.gitlab.io/brain/20210206061032-neuron/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206061032-neuron/</guid><description>The control structure underpinning the human brain.
In roughly 1 \( {mm}^{3} \) each neuron typically [see page 4, connects] to 10,000 other neurons and there're 10,000 Post-synaptic neurons in 3km of wires.
Structure The neuron is [see page 5, divided] into:
Part Description Synapses Controls the strength of the interaction between neurons Dendrites Collects (accumulates) inputs into the Soma Soma Performs a non-linear transformation of the inputs (processes them) Axon Connects the output of the Soma to other neurons through (Axon terminals) Excitation We [see page 9, define] the excitation of a neuron as:</description></item><item><title>Next Generation Access Control</title><link>https://mohkale.gitlab.io/brain/20210211223041-next_generation_access_control/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211223041-next_generation_access_control/</guid><description>An alternative to ACM that focuses more on [see page 29, controlling the use] of documents and mitigating piracy. For example locking people from sharing purchased books with others or adding DRM.
Techniques for DRM include:
Technique Description Watermarking Adding an indicator to content to track changes. Monitoring Using software/hardware that reports usage to owners. Challenges and Concerns How to implement UA efficiently?</description></item><item><title>Nibble</title><link>https://mohkale.gitlab.io/brain/20210716042529-nibble/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210716042529-nibble/</guid><description>Is a digital unit consisting of 4-bits (commonly a half-byte).</description></item><item><title>NLMS-algorithm</title><link>https://mohkale.gitlab.io/brain/20210107213621-nlms_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210107213621-nlms_algorithm/</guid><description>A normalized variant of LMS Gradient Algorithm which [see page 14, uses] a much easier to calculate step size.
The drawback with this approach is that it's too slow to converge for highly correlated input signals (eg. speech).</description></item><item><title>No-Write-Down, No-Read-Up Policy</title><link>https://mohkale.gitlab.io/brain/20210211234822-no_write_down_no_read_up_policy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211234822-no_write_down_no_read_up_policy/</guid><description>A security [see page 24, model] based on current clearance.
This was quite famously the system used by MULTICS.
Note: The no-write-down policy is AKA the *property.</description></item><item><title>Node Valency</title><link>https://mohkale.gitlab.io/brain/20210622175825-node_valency/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622175825-node_valency/</guid><description>Refers to the number of edges connected to a node in a graph.</description></item><item><title>Noise</title><link>https://mohkale.gitlab.io/brain/20201120195826-noise/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120195826-noise/</guid><description>A collection of random values that can somehow be applied to a texture.
Textures with noise applied to them most often define the noise values beforehand, that way the same pattern is imprinted on the same object for each re-render.
We store a grid of noise (u,v,w) where at [see page 14, each vertex] in the grid we store the noise value. For lattice-noise we store a scalar value and for gradient noise we store a vector.</description></item><item><title>Noise Reduction</title><link>https://mohkale.gitlab.io/brain/20201127210910-noise_reduction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127210910-noise_reduction/</guid><description>Is the [see page 3, process] of reducing the amount of noise in a recorded signal.
Channel Description Single Channel Relies on one microphone Multi Channel Relies on multiple microphones (like ears) to exploit spatial information. This is often done using a beam former.</description></item><item><title>Non-interference</title><link>https://mohkale.gitlab.io/brain/20210212004320-non_interference/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210212004320-non_interference/</guid><description>Is an alternative to MAC created by Goguen and Meseguer:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Actions by high level subjects (eg. top secret) should not be visible (flow down to) to lower level subjects.</description></item><item><title>Non-Stationary Sounds</title><link>https://mohkale.gitlab.io/brain/20210129071535-non_stationary_sounds/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129071535-non_stationary_sounds/</guid><description>Are speech sounds that do [see page 12, change] over time, unlike stationary-sounds. This extends to:
dipthongs plosives affricates glides</description></item><item><title>NordVPN</title><link>https://mohkale.gitlab.io/brain/20210417020453-nordvpn/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210417020453-nordvpn/</guid><description>Is a VPN service.
SOCKs Proxy Nord provides several proxy hosts that all support the SOCKS5 protocol. You can use these hosts with a URL of the form:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } `socks5://:@host[:]` I recommend using RYEcxggQw74BepaZRLwbe1S8:pqukGTAAYbns6rTbHbFvyr4c@atlanta.us.socks.nordhold.net.</description></item><item><title>Normal Distribution</title><link>https://mohkale.gitlab.io/brain/20210622164506-normal_distribution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622164506-normal_distribution/</guid><description>Is a continuous probability distribution defined as a bell-curve with the following properties:
The distribution is symmetrical about the mean \( \mu \). The mode, median and mean are all equal. About 68% of values lie within 1 standard deviation of the mean. About 95% of values lie within 2 standard deviations. About 100% of values lie within 3 standard deviations. It has 2 parameters the mean \( \mu \) and the standard deviation \( \sigma \).</description></item><item><title>Normal Mapping</title><link>https://mohkale.gitlab.io/brain/20201109203052-normal_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109203052-normal_mapping/</guid><description>Is an alternative to bump-mapping which stores the normals themselves on a texture, rather than altering an existing normal using the texture.
The texture stored is in RGB and encodes both the intensity of the normal and it's orientation. The RGB values equate the XYZ axes and a point in this space determines the direction and length of a normal.
Note: You can quickly [see page 32, calculate] a normal-map from a bump-map.</description></item><item><title>Normal Matrix</title><link>https://mohkale.gitlab.io/brain/20201107225636-normal_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201107225636-normal_matrix/</guid><description>Is a variant of the model-matrix specifically tailored for use in calculating vertex-normals.
This is required because some translation operations on vector normals don't preserve the perpendicular quality of the normal. For example, a non-uniform scale operation can distort the direction of the normal.
This matrix is defined as:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } The transpose of the inverse of the upper-left 3x3 part of the model matrix.</description></item><item><title>Normalised Device Coordinates</title><link>https://mohkale.gitlab.io/brain/20201023011922-normalised_device_coordinates/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023011922-normalised_device_coordinates/</guid><description>The coordinate space used by OpenGL. OpenGL can only process coordinates when their in the specific range between \(-1.0\) and \(+1.0\). Any coordinates outside this range are discarded/clipped by OpenGL.</description></item><item><title>Notch Filter</title><link>https://mohkale.gitlab.io/brain/20201121015637-notch_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201121015637-notch_filter/</guid><description>The use of filtering to remove interference and noise.
Works by allowing all frequencies through except the specific frequencies (of the noise/interference) which it suppresses.</description></item><item><title>NTP</title><link>https://mohkale.gitlab.io/brain/20211010030754-ntp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010030754-ntp/</guid><description>An application layer protocol for keeping a computers clock synced with the outside world.</description></item><item><title>Nuisance</title><link>https://mohkale.gitlab.io/brain/20201114183243-nuisance/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114183243-nuisance/</guid><description>Actions cause a substantial and unreasonable annoyance with a persons land.
causing too much noise. littering.</description></item><item><title>Number Notation</title><link>https://mohkale.gitlab.io/brain/20210716034159-number_notation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210716034159-number_notation/</guid><description>Is a format for representing numbers, often with a given base and each increasing digit representing a higher power of that base. Some notation use a decimal point to represent lower powers of the base than 0 such as -1.
For example in base-10 the number 45.6 can be seen as \( 45.6 = 4 \times 10^1 + 5 \times 10^0 + 6 \times 10^{-1} \).</description></item><item><title>Numbers</title><link>https://mohkale.gitlab.io/brain/20210621211508-numbers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621211508-numbers/</guid><description>Symbol Name Example \( \mathbb{N} \) Natural Numbers 1,2,3,4,\ldots \( \mathbb{N_0} \) 0,1,2,3,\ldots \( \mathbb{Z} \) Integers \ldots,-3,-2,-1,0,1,2,3,4,\ldots \( \mathbb{Z}^{+} \) Positive integers 1,2,3,4,\ldots \( \mathbb{Q} \) Rational Anything representable as a fraction. \( \mathbb{R} \) All Real Numbers \( \mathbb{C} \) All Complex Numbers Number Rationality Refers to whether a number can be quantified to an exact decimal place.</description></item><item><title>Numeric Intervals</title><link>https://mohkale.gitlab.io/brain/20210621203938-numeric_intervals/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621203938-numeric_intervals/</guid><description>Specifies a range of values.
Round bracket notation excludes the end value, square bracket notation includes it.
Table 1: Examples of the difference between round and square bracket notation. Notation Meaning \( [0, 20] \) 0,1,\ldots,19,20 \( (0, 20) \) 1,2,\ldots,18,19 \( (0, 20] \) 1,2,\ldots,19,20 \( [0, 20) \) 0,1,\ldots,18,19</description></item><item><title>Numerical Methods</title><link>https://mohkale.gitlab.io/brain/20210621225632-numerical_methods/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621225632-numerical_methods/</guid><description>Refers to several methods to determine whether a curve has a root in the interval \( [a,b] \).
To do this you must show that there's a change in sign between \( f(a) \) and \( f(b) \) and that there is continuity on the equation between the points \( x=a \) and \( x=b \).
Warn: without continuity a change of sign no longer guarantees the presence of a root.</description></item><item><title>Nyquist-Shannon Theorem</title><link>https://mohkale.gitlab.io/brain/20201102170713-nyquist_shannon_theorem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102170713-nyquist_shannon_theorem/</guid><description>Sampling frequency must be twice the length of the largest frequency of sound being sampled.
Using a sampling period smaller than this leads to aliasing (energy at frequencies larger than the sampling frequency are reflected back into the lower frequencies).
Note: We [see page 6, often] use a low pass filter on a signal before sampling to avoid aliasing.</description></item><item><title>Object</title><link>https://mohkale.gitlab.io/brain/20210211061106-object/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211061106-object/</guid><description>A resource that can be accessed (execute an operation on). eg. read/write/execute.
Can be a physical object, a function call, or data/information.</description></item><item><title>Object Constraint Language</title><link>https://mohkale.gitlab.io/brain/20210924043442-object_constraint_language/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210924043442-object_constraint_language/</guid><description>Is a sort of first-order logic for UML diagrams that simplifies defining [see page 6, constraints].
The general idea is to qualify path expressions in UML diagrams to constrain sets of objects reachable via associations.
Table 1: Listing of the available collection see page 15, [types] in OCL. Type Ordered Can contain duplicates? Set Unordered No, unique Bag Unordered Yes OrderedSet Ordered No, unique Sequence Ordered Yes Path Expressions Is a way of navigating from an object to a related object or collection of related objects.</description></item><item><title>Object Diagram</title><link>https://mohkale.gitlab.io/brain/20210924033950-object_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210924033950-object_diagram/</guid><description>Is a UML diagram [see page 15, derived] from the class diagram that shows a snapshot of a system at a given state. It has a series of objects each linked to other objects, with links demonstrating the established associations in the parent class diagram.
Objects are instances of a class and identified by an underlined class name (of the form variableName: className). You can add an association tagged with &amp;lt;&amp;lt;instanceOf&amp;gt;&amp;gt; from an object to its class when placing them in a class diagram.</description></item><item><title>Object Oriented Programming</title><link>https://mohkale.gitlab.io/brain/20210911154915-object_oriented_programming/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911154915-object_oriented_programming/</guid><description>Is a model of programming based on the use of classes.
A class is a blueprint for an object. An object is an instance of a class. Object oriented programming makes heavy use of the concept of generalisation, with classes striving to implement the smallest amount of code needing to fulfil their purpose. More general, or not directly applicable behaviour, is implemented in higher level classes or mixins and then inherited from in the base class.</description></item><item><title>Observer Pattern</title><link>https://mohkale.gitlab.io/brain/20210911201702-observer_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911201702-observer_pattern/</guid><description>Is a software design pattern where an object (the subject) maintains a list of its dependants (called observers) that are automatically notified of state changes by calling one of their methods.
This pattern registers objects for callbacks [see page 24, indicating] late design fixes.
\begin{figure} \centering \begin{tikzpicture} \umlclass{Subject}{}{add(Observer) \\ remove(Observer) \\ notifyObservers()} \umlclass[x=6cm]{Observer}{}{notify()} \umlclass[x=4cm, y=-3cm]{ObserverA}{}{notify()} \umlclass[x=8cm, y=-3cm]{ObserverB}{}{notify()} \umlnote[y=-3cm]{Subject}{forall o in observers: o.notify()} \umlVHVinherit{ObserverA}{Observer} \umlVHVinherit{ObserverB}{Observer} \umlaggreg[attr2=observers|0..*, pos=0.7]{Subject}{Observer} \end{tikzpicture} \caption{The observer pattern.} \end{figure}</description></item><item><title>Octal</title><link>https://mohkale.gitlab.io/brain/20210716034032-octal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210716034032-octal/</guid><description>Is a number notation using base-8.
Digits in octal range from [0-8] and are commonly prefixed with 0 (or 0o) in programming languages. For example the octal number 11 is \( 1 \times 8^1 + 1 \times 8^0 = 9 \).
In the olden days octal was commonly used on 36-bit architecture machines.</description></item><item><title>Offer</title><link>https://mohkale.gitlab.io/brain/20201018222704-offer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018222704-offer/</guid><description>The first part of contract negotiation.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } An unequivocal indication of a willingness to be legally bound by a promise if the terms of the offer are met - includes all the essential terms ([see page 16, [source](MGT388-law-w01)]). Offers can be:
Type Description Bilateral One to one. Unilateral One to a group of people (or the whole world).</description></item><item><title>Oja's Rule</title><link>https://mohkale.gitlab.io/brain/20210220173525-oja_s_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220173525-oja_s_rule/</guid><description>A hebbian rule which uses a [see page 5, homeostatic] term to stabilise the change in weights ([see page 13, decreasing] the weights in relation to the strength of the output).
\begin{align} \Delta{w_{ij}} = \alpha v_i^{\text{post}} v_j^{\text{pre}} - \alpha w_{ij}(v_i{\text{post}})2 \end{align}
Note: We can [see page 4, rewrite] ojas rule using the equation for the output of a neuron to get: \[ \Delta{w_{j}} = \alpha y (x_j - w_j y) \] We also need to [see page 5, update] the equation for the average weight update.</description></item><item><title>Omega Notation</title><link>https://mohkale.gitlab.io/brain/20210628051009-omega_notation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628051009-omega_notation/</guid><description>An asymptotic function which provides a tight [see page 14, lower] bound. A function \( f(n) \) belongs to the set \( \Omega(g(n)) \) if it can be shown that there's a constant \( c \) such that the function is always larger than \( g(n) \) for sufficiently large \( n \).
\begin{align*} \Omega(g(n)) = \{ f(n) : &amp;amp; \text{\; there exists constants \;} 0 &amp;lt; c \text{\; and \;} n_0 \text{\; such that \;} \\</description></item><item><title>One-to-One Function</title><link>https://mohkale.gitlab.io/brain/20210621190109-one_to_one_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621190109-one_to_one_function/</guid><description>A one-to-one function is a function where each outputs occurs for only one input. That is to say \( \exists ! x_1, x_2 \forall x_1, x_2 \in \mathbb{R}, f(x_1) = f(x_2) \land x_1 \neq x_2 \).</description></item><item><title>OpenGL</title><link>https://mohkale.gitlab.io/brain/20201011184901-opengl/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201011184901-opengl/</guid><description>An API for cross platform graphical rendering across multiple available hardware and software environments. The OpenGL system is implemented as a large state machine, with API calls modifying the state (such as pushing data onto the GPU where rendering calculations are much quicker than the CPU).
Initialise OpenGL guide Before we can get to drawing with opengl we need a window to draw in. This is generally a platform specific problem and with OpenGL actively trying to be generic we have to do this ourselves.</description></item><item><title>Operating Cycle</title><link>https://mohkale.gitlab.io/brain/20210112041432-operating_cycle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210112041432-operating_cycle/</guid><description>The average time from cash outflow (buying items) and cash inflow (producing and selling items) defines the operating cycle.</description></item><item><title>Operating System</title><link>https://mohkale.gitlab.io/brain/20210717022400-operating_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717022400-operating_system/</guid><description>Is a computer program that abstracts the messy details of controlling a computers hardware. It takes care of memory management, disk interaction, and user facing concerns such as the UI, shell, GUI tools and services.</description></item><item><title>Opinion Mining</title><link>https://mohkale.gitlab.io/brain/20201110210022-opinion_mining/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110210022-opinion_mining/</guid><description>Finding all opinion-quintuples in a document.
Can be used to give a:
Analysis Description Quantitative Which proportion of opinions are +ve/-ve? Qualitative Which components are good, which are bad?</description></item><item><title>Opportunity Cost</title><link>https://mohkale.gitlab.io/brain/20201114221321-opportunity_cost/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114221321-opportunity_cost/</guid><description>The [see page 4, value] of the benefits sacrificed when one course of action chosen over another action.</description></item><item><title>Optimal Substructure</title><link>https://mohkale.gitlab.io/brain/20210628054647-optimal_substructure/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054647-optimal_substructure/</guid><description>A [see page 8, property] for a problem where the solutions to the sub-problems used within the optimal solution are themselves optimal.</description></item><item><title>Optimistic-Greedy Reward Policy</title><link>https://mohkale.gitlab.io/brain/20210415002840-optimistic_greedy_reward_policy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415002840-optimistic_greedy_reward_policy/</guid><description>A policy that starts with very high Q-values and choose greedily. We normally start with Q-values of 0 and increase them as we learn. This approach starts by taking the best path first and then decreasing Q-values to try and find a better path.</description></item><item><title>Orphan Process</title><link>https://mohkale.gitlab.io/brain/20211002211354-orphan_process/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002211354-orphan_process/</guid><description>Is a process whose parent has exited without waiting on it.
In such a case the orphaned processes parent PID is reset to the init process (PID = 1).</description></item><item><title>OS Forensics</title><link>https://mohkale.gitlab.io/brain/20210318003507-os_forensics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210318003507-os_forensics/</guid><description>Variant of digital forensics targeting evidence stored on operating systems.
Common evidence found on operating systems ([see page 3, windows] and [see page 4, linux]) includes:
Documents, Images, Videos, etc. Emails Browser/Search history Security Event Logs (syslogs and C:\\Windows\\System\\winevt\\logs) Recycle Bin Common points of interest in OS forensics includes:
Left over data in Slack Space. Page Files.</description></item><item><title>OSI Model</title><link>https://mohkale.gitlab.io/brain/20210428234225-osi_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428234225-osi_model/</guid><description>Provides the physical description of transferring data between two hosts in a network. When we refer to a layer in discussions about the internet, TCP, UDP, etc. we mean a layer as described in the OSI model.
OSI Layers The model divides the transference of data into several layers.
Physical Layer Is the lowest layer of the model in charge of transferring and receiving unstructured raw data between the machine and a physical transmission medium.</description></item><item><title>Out-of-Order Execution</title><link>https://mohkale.gitlab.io/brain/20211010225625-out_of_order_execution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010225625-out_of_order_execution/</guid><description>Is a feature of modern (1990s+) processors where the processor can execute other instructions while waiting for the current instruction to complete. So for example you could be assigning a variable, but while you're waiting for that write to memory to complete the processor could execute the next few instructions while waiting.
Note: If any of the operations would possibly alter the final result, there is a barrier, or if the re-ordering violates the data dependencies of the instructions, the processor keep the instructions in the stated order.</description></item><item><title>Output Feedback Mode</title><link>https://mohkale.gitlab.io/brain/20210216013810-output_feedback_mode/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216013810-output_feedback_mode/</guid><description>A mode of use for cipher-blocks which encrypts a sequence of input blocks (for example with ECB) to produce a sequence of intermediate output blocks which are XORed with the plaintext to produce ciphertext blocks.
Note: The first input-block is an initialisation-block IV.
Subsequent input-blocks are output-blocks from previous rounds.
This approach essentially converts a block-cipher into a stream-cipher.</description></item><item><title>Overdraft</title><link>https://mohkale.gitlab.io/brain/20201021171919-overdraft/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021171919-overdraft/</guid><description>Allows a company to maintain a [see page 8, negative balance] on a bank account. A flexible form of borrowing with higher interest rates (than a term loan) and is often payable on demand.</description></item><item><title>P-box</title><link>https://mohkale.gitlab.io/brain/20210216005614-p_box/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216005614-p_box/</guid><description>A [see page 27, P-Box] permutation. This reorders the input bits in a predictable way, but doesn't manipulate or otherwise alter the number of 0s or 1s in the input block.
See the [see page 27, DES] example, where the first and last bits of a block are swapped with the last and first bits of the adjacent blocks. With the first and last blocks wrapping-around their first and last bits to each other, as if they were adjacent neighbours.</description></item><item><title>P-code Language</title><link>https://mohkale.gitlab.io/brain/20210718023958-p_code_language/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718023958-p_code_language/</guid><description>Is a hybrid programming language between the compiled and interpreted variants. Such languages take the source code and translate it into a compact binary form, but this form cannot be run directly as machine code. Instead to run the program you interpret the p-code.
P-code can run nearly as fast as a compiled binary but keep the flexibility and power of a good interpreter. Examples of such languages include python and java.</description></item><item><title>Package Diagram</title><link>https://mohkale.gitlab.io/brain/20210906021149-package_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906021149-package_diagram/</guid><description>A UML diagram showing the structure of packages.
\begin{figure} \centering \begin{tikzpicture} \begin{umlpackage}{java/util} \begin{umlpackage}{java/util/jar} \end{umlpackage} \begin{umlpackage}[right=of java/util/jar]{ArrayList} \end{umlpackage} \begin{umlpackage}[below=of ArrayList]{LinkedList} \end{umlpackage} \end{umlpackage} \end{tikzpicture} \caption{Example package diagram.} \end{figure} Constructs uml The package construct is visualised as a [see page 10, folder] used to group logically related source code. It doesn't show instances, only classes.
You can think of packages of namespaces used to isolate functionality to local modules and prevent name clashes.</description></item><item><title>Packet</title><link>https://mohkale.gitlab.io/brain/20210719230852-packet/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719230852-packet/</guid><description>Is a chunk of data that is part of a larger file to be transmitted through the internet.
Each packet contains the:
Source address: of the machine sending the packet. Destination address: of the machine the packet is to be delivered to. Service (port) number: that specifies a port on the device to connect to.</description></item><item><title>Page</title><link>https://mohkale.gitlab.io/brain/20211008015220-paging/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008015220-paging/</guid><description>Is a block of virtual memory. On Linux each block typically has a page-size/block-size of 4KiB (or \( 2^{12} \) addresses).
The number of pages you need can be found by dividing the number of possible addresses by the size of each page. For a 32-bit system this is \( \frac{2{32}}{2{12}} = 2^{20} \) pages and for a 64-bit system it's \( \frac{2{64}}{2{12}} = 2^{52} \) pages.
Pages are required to avoid the overhead of addressing physical memory directly.</description></item><item><title>Page Fault</title><link>https://mohkale.gitlab.io/brain/20211009004612-page_fault/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009004612-page_fault/</guid><description>Is a hardware signal that may be triggered when a process accesses an address in a frame that's missing in memory. These can be categorised into:
Minor: If there is no mapping yet for the page, but it is a valid address. Such as when sbreak is called to enlarge the available heap memory, but the kernel hasn't allocated that space yet. Major: If the mapping to the page is exclusively on disk.</description></item><item><title>Page Files</title><link>https://mohkale.gitlab.io/brain/20210318005938-page_files/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210318005938-page_files/</guid><description>Refers to RAM memory which was [see page 9, moved] from RAM to the file-system.
We can generally find typed commands, passwords, encryption keys, unencrypted data, IP addresses, internet history &amp;amp; more in memory images.
Paging is a method of storing and retrieving data used in the RAM with a virtual memory file stored on a traditional storage device.</description></item><item><title>Page Rank</title><link>https://mohkale.gitlab.io/brain/20201025203510-page_rank/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025203510-page_rank/</guid><description>Googles search ranking algorithm.
Its [see page 24, based] on a simple intuition:
Page A links to page B -&amp;gt; implies B is worth looking at. Each page is given an authority depending on how many pages link to it and what the authority of those pages is. Pages that link to many sources share less authority than those that link to few pages. I.E. Authority is shared on each external link, but spamming links lowers the amount of authority shared.</description></item><item><title>Page Table</title><link>https://mohkale.gitlab.io/brain/20211008235151-page_table/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008235151-page_table/</guid><description>Is a translation table between virtual memory pages and physical frames.
For example page 1 might point to frame 45, page 2 to frame 30, etc. At any time a other or in-between frames may be assigned to another process or used internally by the OS.
Note: The page table isn't limited to just storing address translations. It can also remember properties about the page such as: is it read-only?</description></item><item><title>Pair Programming</title><link>https://mohkale.gitlab.io/brain/20210626230408-pair_programming/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626230408-pair_programming/</guid><description>Is a development style with [see page 27, two] developers, the driver and the navigator, working side by side on each feature. The driver implements the feature and focuses on solving the problem. The navigator questions the driver asking them to justify themselves and provide explanations.
Aside: See The Friendship That Made Google Huge.
The [see page 29, value] of pair programming is in:
All production code is reviewed by at least one other programmer.</description></item><item><title>Pairwise Constrained K-Means Clustering</title><link>https://mohkale.gitlab.io/brain/20210306200208-pairwise_k_means_clustering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210306200208-pairwise_k_means_clustering/</guid><description>A variant of K-Means clustering which uses semi-supervised learning to produce more predictable and reliable clustering models through [see page 9, constraints] on the learning process.
The final algorithm here is the same as the k-means algorithm, except we've adjusted the error function to include our constraints.
Assumptions This approach generally [see page 5, assumes]:
Assumption Description Smoothness Points that're close in the input space should lead to similar outputs (example: same classes).</description></item><item><title>Parabola</title><link>https://mohkale.gitlab.io/brain/20210622000108-parabola/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622000108-parabola/</guid><description>Is a special plane formed from the cartesian equation \( y^2 = 4ax \) for some parameter \( a \). It can also be written through the parametric equation \( x = at^2 \) and \( y = 2at \). This plane has the special property that for all points on the parabola the distance from that point to another point, known as the focus \( (a, 0) \), is equivalent to the distance from that parabola to a special line known as the directrix formed at \( x = - a \).</description></item><item><title>Parametric Curves</title><link>https://mohkale.gitlab.io/brain/20201120212110-parametric_curves/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120212110-parametric_curves/</guid><description>A [see page 2, definition] of a curved path that can be parameterised.
PCs are defined by having a bunch of points (keyframes) we know we want to be on the curve and then interpolating between them to get a curved surface.
A PC can control any changing parameter and we can define multiple parameters with multiple curves to get arbitrary behaviour (eg. [see page 4, object-color], facial poses, etc.). We build this by defining the value of each parameter at different points in time and then constructing a PC between each keyframe.</description></item><item><title>Parametric Function</title><link>https://mohkale.gitlab.io/brain/20210621202806-parametric_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621202806-parametric_function/</guid><description>Functions that use a single parameter to define a more complex shape such as a curve.
A classic example of a parametric-function is a [see page 9, sine] wave.
\begin{align*} x = r \sin t y = r \cos t \end{align*}
It can define the shape of a circle with two functions, one for each axis \((x,y)\) of the shape, using the single parameter \( t, \; 0 \leq t \leq 2 \pi \).</description></item><item><title>Parametric Patches</title><link>https://mohkale.gitlab.io/brain/20201016214218-parametric_patches/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201016214218-parametric_patches/</guid><description>A form of 3D representation which is commonly used in CAD.
Often referred to as a curvilinear quadrilaterals.
We define a patch (surface) with multiple [see page 3, control structures] that can be used to alter the surface of the patch. Think of it as a continuous curve with a known mathematical equation. We define \(n\) points for which the value of the curve is known and then use a [see page 4, blending] function to interpret how the surface of the patch varies across the different control structures between those points.</description></item><item><title>Partial Fractions</title><link>https://mohkale.gitlab.io/brain/20210621221245-partial_fractions/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621221245-partial_fractions/</guid><description>A way to simplify repeated terms in a algebraic fraction, based on shared factorised terms.
For example:
\begin{align*} \frac{3x^2 - 6x + 3}{12x^2 - 6x -6} &amp;amp;= \frac{3(x2-2x+1)}{6(2x2-x-1)} \\
&amp;amp;= \frac{3(x-1)^2}{6(2x+1)(x-1)} \\\\ &amp;amp;= \frac{x-1}{2(2x+1)} \end{align*}
Generally we solve partial fractions when the numerator is heavier than or equal to the denominator, that is the largest power of x on the numerator is larger than the largest power of x in the denominator.</description></item><item><title>Partial Function</title><link>https://mohkale.gitlab.io/brain/20210627010542-partial_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010542-partial_function/</guid><description>Is a function that is [see page 21, defined] for a subset of its domain. It may throw an error or invalid output when given some values within its domain.</description></item><item><title>Partial Order Reflection</title><link>https://mohkale.gitlab.io/brain/20210627014624-partial_order_reflection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627014624-partial_order_reflection/</guid><description>Is a homogeneous relation that is reflexive, anti-symmetric and transitive. See [see page 14, here].</description></item><item><title>Partition</title><link>https://mohkale.gitlab.io/brain/20210627014953-partition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627014953-partition/</guid><description>For a set \( A \) a [see page 21, partition] is a set of disjoint subsets of \( A \), \( A_i \forall i \in I \) where the intersection of all the elements of the partition gives back \( A \). That is \( \bigcup_{i \in I} A_i = A \).
We define a specific element of the partition (for example \( A_0 \)) as a block.
Partition Refinement A partition where every block is a subset of a block of the one being [see page 21, refined].</description></item><item><title>Partitioned Architecture</title><link>https://mohkale.gitlab.io/brain/20210906023741-partitioned_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906023741-partitioned_architecture/</guid><description>A Software Architecture where different business areas are handled by separate subsystems. Uses vertical [see page 11, partitions], where each partition manages its own UI, business logic and data storage, with weak coupling between them.
\begin{figure} \centering \begin{tikzpicture}[line/.style={very thick, dashed}] \begin{umlpackage}[type=subsystem]{Financial Investments}\end{umlpackage} \begin{umlpackage}[type=subsystem, right=0.8cm of Financial Investments]{Production and Sales}\end{umlpackage} \begin{umlpackage}[type=subsystem, right=0.8cm of Production and Sales]{Loans and Credit}\end{umlpackage} \draw [line, -&amp;gt;] (Production and Sales) -- (Financial Investments); \draw [line, -&amp;gt;] (Production and Sales) -- (Loans and Credit); \end{tikzpicture} \caption{Partitioned Architecture} \end{figure}</description></item><item><title>Patent</title><link>https://mohkale.gitlab.io/brain/20201104175659-patent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201104175659-patent/</guid><description>.org-center { margin-left: auto; margin-right: auto; text-align: center; } "A patent is an exclusive right granted for an invention, which is a product or a process that provides, in general a new way of doing something, or offers a new technical solution to a problem". [see page 5, patents] incentivises innovation and last 20 years from the date of application acceptance.
In the UK, we can [see page 6, get] a patent by:</description></item><item><title>Path</title><link>https://mohkale.gitlab.io/brain/20210622174108-path/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174108-path/</guid><description>In relation to a graph, a path is a finite sequence of edges such that the end of a vertex of an edge in the sequence is the start vertex of the next edge and in which no vertex appears more than once.</description></item><item><title>Path Tracing</title><link>https://mohkale.gitlab.io/brain/20210106021544-path_tracing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106021544-path_tracing/</guid><description>Is an [see page 13, alternative] to advanced-ray-tracing which both shoots many rays per pixel, but only one ray directed randomly for each intersection, until a light source is hit (or TERMINATE). Once this is done we use the angles of the intersection and the material properties to determine the color for that pixel.
This technique is generally dependent on the number of rays we send out per-pixel, with the larger the number leading to a better approximation of the actual scene.</description></item><item><title>Pattern Attack</title><link>https://mohkale.gitlab.io/brain/20210215022759-pattern_attack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215022759-pattern_attack/</guid><description>Is a possible [see page 11, attack] on simple (mono-alphabetic) substitution ciphers which exploits the occurrence of common expressions in an input. For example &amp;quot;The quick brown fox jumps over the lazy dog&amp;quot;.
If you can detect the general permutation of these characters in the same positions in an input you can quickly decode their underlying mappings. For example the letter o occurs at position 13 and 18 in the plaintext.</description></item><item><title>Payment Period</title><link>https://mohkale.gitlab.io/brain/20201021174632-payment_period/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021174632-payment_period/</guid><description>How [see page 29, soon] after a purchase a company pays it's suppliers.
\[ \frac{Trade Payables}{Cost of Sales} \]
You should generally try to pay on time because:
it can lead to discounts, enhancing profitability. it keeps a good relationship with your suppliers.</description></item><item><title>PCI</title><link>https://mohkale.gitlab.io/brain/20210717015608-pci/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717015608-pci/</guid><description>Is the bus type used in most modern PCs (+ Macs).</description></item><item><title>PCMCIA</title><link>https://mohkale.gitlab.io/brain/20210717015724-pcmcia/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717015724-pcmcia/</guid><description>Is a variant of ISA with smaller physical connectors used on laptop computers.</description></item><item><title>Penetration Testing</title><link>https://mohkale.gitlab.io/brain/20210607001137-penetration_testing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607001137-penetration_testing/</guid><description>An authorised, simulated, cyber-attack on a computer system performed to evaluate the security of the system.</description></item><item><title>Percept</title><link>https://mohkale.gitlab.io/brain/20210926222507-percept/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926222507-percept/</guid><description>An agents perceptual inputs at a point in time.</description></item><item><title>Percept Sequence</title><link>https://mohkale.gitlab.io/brain/20210926222534-percept_sequence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926222534-percept_sequence/</guid><description>The complete history of every percept an agent has ever received.</description></item><item><title>Perfect Forward Secrecy</title><link>https://mohkale.gitlab.io/brain/20210429001338-perfect_forward_secrecy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429001338-perfect_forward_secrecy/</guid><description>The concept of a secure communication system where even if the traffic and one of the users keys is deciphered the attacker is still unable to read the encrypted correspondences.
Perfect forward secrecy generally addresses faults in session keys, [see page 34, consider]:
- Alice encrypts a message with shared key K and sends cipher text to Bob. - Trudy records ciphertext and later attacks Alice (or Bobs) computer to recover K - Trudy now decrypts recorded message.</description></item><item><title>Peri Stimulus Time Histogram</title><link>https://mohkale.gitlab.io/brain/20210206070104-peri_stimulus_time_histogram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206070104-peri_stimulus_time_histogram/</guid><description>An alternative representation to neural spike rates, which averages the number of spikes across \( k \) neurons over a small time interval \( \Delta{t} \). \[ \text{PSTH}(t) = \frac{n(t; t + \Delta{t})}{K \Delta{t}} \]</description></item><item><title>Permutation Cipher</title><link>https://mohkale.gitlab.io/brain/20210215031022-permutation_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215031022-permutation_cipher/</guid><description>A sort of cipher which [see page 14, shuffles] the plaintext in some way (reorders the position of characters in the plain-text).
For example the Scytale cipher writes a message on a belt and then wraps it around a baton, reading it left-to-right to get the cipher-text. The key so-to-speak in this case is the diameter of the rod.
Another [see page 15, example] reads characters in blocks of 5 and shuffles them using the key \( \{2,1,5,3,4\} \).</description></item><item><title>Perspective Projection</title><link>https://mohkale.gitlab.io/brain/20201106230102-perspective_projection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106230102-perspective_projection/</guid><description>Perspective projection adjusts the sizes of objects in the distance to appear smaller than those that're closer.
See more here.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } The [perspective] projection matrix maps a given frustum range to clip space, but also manipulates the w value of each vertex coordinate in such a way that the further away a vertex coordinate is from the viewer, the higher this w component becomes.</description></item><item><title>Phase Shift</title><link>https://mohkale.gitlab.io/brain/20201110161419-phase_shift/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110161419-phase_shift/</guid><description>Is defined as the change in angle between the same point in two waves (see here).
That is to say the smallest horizontal delta needed for a point travelling in one wave to reach the same amplitude in another wave. Or the amount you'd need to add (or subtract) from a waves angle before they perfectly overlap.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Let s1 = sin(x), s2 = sin(y) and pd = phase difference between s1 and s2.</description></item><item><title>Philosophy in AI</title><link>https://mohkale.gitlab.io/brain/20200704223757-philosophy_in_ai/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200704223757-philosophy_in_ai/</guid><description>Paradigms over the years Rationalism everything can be rationally explained through observation (the world and our actions are deterministic).
Dualism Something else (metaphysical) contributes to human intelligence.
Materialism The brain does operate according to the laws of physics. Free will is simply the how available choices appear to the choosing entity.
Empiricism Knowledge is based on (or derivced from) the senses.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Nothing is in the understanding which was not first in the senses.</description></item><item><title>Phising</title><link>https://mohkale.gitlab.io/brain/20210211054626-phising/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211054626-phising/</guid><description>A social-engineering attack relying on tricking users into giving away vulnerable info. For eg. by sending an email to someone telling them their passwords been compromised and then sending them to a fake password-reset page.</description></item><item><title>Phonation</title><link>https://mohkale.gitlab.io/brain/20210129001654-phonation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129001654-phonation/</guid><description>The term used to describe the repeated opening and closing of vocal-cords.</description></item><item><title>Phone</title><link>https://mohkale.gitlab.io/brain/20201026211835-phone/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026211835-phone/</guid><description>Any distinct speech sound or gesture regardless of whether the exact sound is critical to the meanings of words.
In [see page 2, practice] only a certain number of phones occur in any language (even though all phones can occur in all languages).</description></item><item><title>Phoneme</title><link>https://mohkale.gitlab.io/brain/20201026211728-phoneme/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026211728-phoneme/</guid><description>Phones in a language which're contrastive. They can be used to distinguish one word from another.</description></item><item><title>Phonemics</title><link>https://mohkale.gitlab.io/brain/20201026211246-phonemics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026211246-phonemics/</guid><description>The study of the psychophonic (language-dependent) parts of speech. How we interpret and compensate for sound quality.
Phonemic transcriptions are written in IPA with / surrounding the transcription (eg. \(/fasI/\)). These transcriptions don't represent actual sounds, but the ideal representation of them. In [see page 6, practice] there're several different ways to sound the same phonetic sequence.
Phonemic Contrast Early phoneticians realised that acoustically distinct speech sounds were only percieved as different if they signalled the difference between one word and another.</description></item><item><title>Phonetic Writing Systems</title><link>https://mohkale.gitlab.io/brain/20210129042106-sound_based_writing_systems/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129042106-sound_based_writing_systems/</guid><description>Writing systems which are based on how the words [see page 2, sound] phonetically (see [see page 7, here]).
Such systems are an example of [see page 5, visible speech].
Transcriptions from a language to a phonetic writing system are often surrounded in square brackets.
Syllabaries Symbols represent a consonat plus a vowel (or a single vowel).
Eg. Cherokee, Japanese.
Abjads Symbols mainly represent just consonants. Most of these are written right to left.</description></item><item><title>Phonetics</title><link>https://mohkale.gitlab.io/brain/20201016204840-phonetics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201016204840-phonetics/</guid><description>The study of the psysiophonic (language-independent) parts of speech. Essentially how we produce and classify sound.</description></item><item><title>Phong Illumination</title><link>https://mohkale.gitlab.io/brain/20201023194959-phong_illumination/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023194959-phong_illumination/</guid><description>An illumination algorithm in 4 [see page 7, stages], which only supports direct illumination and lacks support for shadows or inter-reflection between objects.
We define the light intensity:
\begin{align*} \mathrm{Reflected Light} &amp;amp;= \mathrm{Ambient} + \mathrm{Diffuse} + \mathrm{Specular} \
l &amp;amp;= (k_a \times l_a) + (k_d \times l_d) + (k_s \times l_s) \end{align*}
Such that \[ k_a + k_d + k_l = 1 \].
This can also be [see page 15, rewritten] as: \[ I = k_a \times l_a + I_L(k_d(L.</description></item><item><title>Phong Interpolative Shading</title><link>https://mohkale.gitlab.io/brain/20201023210418-phong_interpolative_shading/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023210418-phong_interpolative_shading/</guid><description>A way of shading in which we [see page 27, bilinearly interpolate] the normals of each of the three points across the surface of the polygon and then calculate an intensity for each pixel.
See here and [see page 41, here] if you're still confused. I.E. PIS [see page 42, interpolates] between vertex normals at as fine a resolution as you're rendering.
Costs Vector interpolation is 3 times more expensive than intensity interpolation.</description></item><item><title>Phonological Process</title><link>https://mohkale.gitlab.io/brain/20201026221947-phonological_process/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026221947-phonological_process/</guid><description>Various [see page 6, processes] as a consequence of phonology.
These vary the phonetic execution of a sound, but leave the phonemic interpretation of it unchanged.
Assimilation (Feature Spreading) You replace one sound with another but you can't hear the difference.
Elision (deletion) Sounds can go missing. I don't know -&amp;gt; I dunno.
Epenthesis (Insertion) Shortening the gap between words using sounds. eg. Vanilla . Ice . Cream -&amp;gt; VanillarIceCream We use the [r] sound to buffer between the vanilla and ice words.</description></item><item><title>Phonology</title><link>https://mohkale.gitlab.io/brain/20201026211137-phonology/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026211137-phonology/</guid><description>A generic term describing [see page 1, anything] to do with the sounds people make when communicating using speech. This can be subdivided into:
phonetics. Phonemics.</description></item><item><title>Physical Constraints</title><link>https://mohkale.gitlab.io/brain/20210906003715-physical_constraints/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906003715-physical_constraints/</guid><description>Constraints that affect the physical properties of the system.
Is it stand-alone or distributed? Is it single user access or distributed? Is it a single product or a component in a larger system?</description></item><item><title>Piling Up Lemma</title><link>https://mohkale.gitlab.io/brain/20210216024307-piling_up_lemma/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216024307-piling_up_lemma/</guid><description>\begin{align} \label{eq:matsui-lemma} P(X_1 \xor X_2 \xor ... \xor X_n = 0) = \frac{1}{2} + 2^{n-1} \prod^{n}_ \epsilon_i \end{align}
Where:
\( X_i \) is a random variable with possible values \( \{0,1\} \) whose value is independent of all other random variables \( X_n \forall n \in \mathbb{Z} \land n \ne i \). \( p(x=0) \) the probability of the random variable \( x \) being \( 0 \) \( \epsilon_i \) is the bias of the random variable \( i \).</description></item><item><title>Pipelined Architecture</title><link>https://mohkale.gitlab.io/brain/20210906023833-pipelined_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906023833-pipelined_architecture/</guid><description>A software architecture where data transformations are handled by separate subsystems and data flows from one subsystem to the next.</description></item><item><title>Pipes</title><link>https://mohkale.gitlab.io/brain/20211009011250-pipes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009011250-pipes/</guid><description>Is a POSIX kernel construct that simply takes a stream of bytes as input and writes a stream of bytes as output. See the pipe system-call.
Pipes are designed such that they can be chained. A common example of this is your shell. Each command in a shell pipeline has its own dedicated process and has its standard-output linked to the next commands input and its standard-input connected to the previous commands output.</description></item><item><title>Pitch</title><link>https://mohkale.gitlab.io/brain/20210128045956-pitch/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128045956-pitch/</guid><description>The frequency at which repetition occurs in a sound wave.</description></item><item><title>Plain-text Attack</title><link>https://mohkale.gitlab.io/brain/20210606014205-plain_text_attack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210606014205-plain_text_attack/</guid><description>is a security attack on a cryptographic system in [see page 25, which] we know both the plaintext and the ciphertext passing through the system.</description></item><item><title>Plasticity</title><link>https://mohkale.gitlab.io/brain/20210222234423-plasticity/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210222234423-plasticity/</guid><description>The [see page 5, term] for the affect of a learning-rule on a neural network which causes a change in weights dependent on some other quantities involved in the calculation of a neurons output potential.</description></item><item><title>Point Light</title><link>https://mohkale.gitlab.io/brain/20201108020144-point_light/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201108020144-point_light/</guid><description>A light source with a configurable location and attenuation applied to it.
Converse to a directional-light, point lights degrade their affect as the distance from the light increases.</description></item><item><title>Pointers</title><link>https://mohkale.gitlab.io/brain/20220111114832-pointers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220111114832-pointers/</guid><description>Are values that point to addresses in memory and act as a way to implement pass-by-reference for languages such as C.
Ordinarily when we call a function a new stack frame is created where the values of all our arguments are copied in. If we pass a pointer the pointer itself is copied but we can dereference the pointer to access and modify the value the pointer references.
Note: Java is a classic example of a language in which everything is pass by value.</description></item><item><title>Poles &amp; Zeros</title><link>https://mohkale.gitlab.io/brain/20210131024902-poles_and_zeros/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131024902-poles_and_zeros/</guid><description>Refers to the [see page 10, points] at which the numerator or denominator of the z-plane transfer function equals \(0\).
The transfer function can be rewritten as the ratio of two polynomials in terms of \( z \). \[ H[z] = \frac{P[z]}{Q[z]} \]
Given this definition anywhere we encounter:
Condition Consequence Corresponds to frequencies where the filter function tends to: \( P[z] = 0 \) Zeros Zero (I.</description></item><item><title>Poly-alphabetic Substitution Cipher</title><link>https://mohkale.gitlab.io/brain/20210215022127-poly_alphabetic_substitution_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215022127-poly_alphabetic_substitution_cipher/</guid><description>A Substitution Cipher in which each character of the input doesn't necessarily always map to the same character.
For example a cipher built using [see page 12, multiple] ceaser-ciphers where: Each characters position in the input leads to it being passed to a different cipher (for example characters with odd cardinality get passed through a ceaser-cipher with offset 5 but those with an even cardinality get passed through one with an offset 13).</description></item><item><title>Polygon</title><link>https://mohkale.gitlab.io/brain/20210322174917-polygon/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210322174917-polygon/</guid><description>A 3D pixel, often represented as a triangle.
Why a Triangles? Triangles are used [see page 474, because]:
They are the simplest kind of polygon... less than three points can't form a surface. Are flat (planar). The first 3 vertices define a plane, but a \nth{4} may be above or below it. They remain triangular under most kinds of transformations Their usage is widespread.</description></item><item><title>Polygon Mesh</title><link>https://mohkale.gitlab.io/brain/20201008155734-polygon_mesh/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201008155734-polygon_mesh/</guid><description>A way of representing 3d objectsusing a mesh of polygonal facets.
The alternative names refer to how we're representing the boundary of an object. We can't exactly represent a 3D Mesh, we only ever have an approximation.
The direction of a polygon (facing towards or away from the frame of reference) is determined using vertex-normals.
The most common kind of polygon used is a triangle because their always flat, you can't twist the vertices of a triangle (like you could with a square).</description></item><item><title>Port</title><link>https://mohkale.gitlab.io/brain/20211009201907-port/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009201907-port/</guid><description>Is an access number often used alongside an address to indicate an end-point for a network connection.
A port isn't a distinct host, instead its a number on a host that can be bound to and sent data distinct from any other ports. This allows computers to develop standards over what sort of data they can expect when a port is open, listening, for a connection (example port 22 is commonly used for SSH connections).</description></item><item><title>Post-Synaptic Neurons</title><link>https://mohkale.gitlab.io/brain/20210206061807-post_synaptic_neuron/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206061807-post_synaptic_neuron/</guid><description>Act as an alternative output bridge for a Neuron for sending signals to other neurons through the Axon.</description></item><item><title>Power Spectrum</title><link>https://mohkale.gitlab.io/brain/20201102154416-power_spectrum/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102154416-power_spectrum/</guid><description>The [see page 11, spectrum] showing the energy present at each frequency in a signal.
Power (at a given frequency) is the sum of the squares of the signals real and imaginary (eg. negative frequencies) components at that frequency.
The phase relationship is lost during calculation of the power spectrum. Meaning you can't reconstruct the original signal from a power spectrum. You'll either need both the real and imaginary parts of the spectrum (seperately) or know the phase relationship between the power spectrum to reconstruct the original signal.</description></item><item><title>Powerset</title><link>https://mohkale.gitlab.io/brain/20210627001254-powerset/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627001254-powerset/</guid><description>Is a set containing [see page 4, all] the subsets of the parent set.
\begin{align*} \mathcal{P}(A) &amp;amp;= \{ x : x \subseteq A \} \
y \in \mathcal{P}(A) &amp;amp;\iff y \subseteq A \
A &amp;amp;\in \mathcal{P}(A) \
\varnothing &amp;amp;\in \mathcal{P}(A) \
\end{align*}</description></item><item><title>Pre-Synaptic Neurons</title><link>https://mohkale.gitlab.io/brain/20210206061345-pre_synaptic_neurons/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206061345-pre_synaptic_neurons/</guid><description>Refers to the neurons \(x,y,...,z\) inputting signals into the synapses of a neuron \(a\) through $a$s Axon terminals.</description></item><item><title>Predicate</title><link>https://mohkale.gitlab.io/brain/20210627005511-predicate/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627005511-predicate/</guid><description>Are propositions defined over (free) variables. For example in the set \( \{ x: x \text{has property} P \} \), the property \( P \) is a [see page 11, predicate] denoted as \( P(x) \).
The truth value of a predicate depends on one or more free-variable, such as \( x \) and specifying a value for \( x \) produces a proposition. We define the see page 12, universe of discourse as the set of possible values for a free variable.</description></item><item><title>Prediction by Partial Matching</title><link>https://mohkale.gitlab.io/brain/20201102005235-prediction_by_partial_matching/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102005235-prediction_by_partial_matching/</guid><description>A finite context model for symbolwise text compression.
The model works by determining the probabilities of symbols in a given (finite) context. This context can be arbitrarily long depending on previously inspected contexts.
Note: PPM with a (semi-)static model can support random access.</description></item><item><title>Predictive Design Models</title><link>https://mohkale.gitlab.io/brain/20210626201523-predictive_design_models/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626201523-predictive_design_models/</guid><description>A software development model that tries to predict all of the features and issues that you may encounter while developing software and try to plan out a road-map for them exhaustively.
These [see page 45, models] don't handle change or fuzzy requirements well.</description></item><item><title>Preemptive Shortest-Job-First Scheduler</title><link>https://mohkale.gitlab.io/brain/20211009140848-preemptive_shortest_job_first_scheduler/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009140848-preemptive_shortest_job_first_scheduler/</guid><description>Is like a SJF scheduler except its aggressively preemptive. if a new process comes in with a shorter runtime than the total runtime of the current job then it is run instead.
This has the same general advantages and disadvantages of an SJF scheduler, except it also results in context switching and constant job interruptions.</description></item><item><title>Pretexting</title><link>https://mohkale.gitlab.io/brain/20210630235109-pretexting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630235109-pretexting/</guid><description>A social engineering attack where we use a fabricated scenario to elicit information. For example a call from someone claiming to work for company-x and asking for you to confirm your personal information.</description></item><item><title>Price &amp; Demand</title><link>https://mohkale.gitlab.io/brain/20201106011533-price_and_demand/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106011533-price_and_demand/</guid><description>Price is determined by the market and can be plotted as a [see page 4, demand] curve.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Demand is dependant on price, low-price -&amp;gt; high-demand. Elasticity A product with an [see page 6, elastic] demand shows a more than proportional change in demand due to a small change in price. Products that can be swapped for a similar product have elastic demand (buyers can quickly switch to it when a discount is presented).</description></item><item><title>Prim's Algorithm</title><link>https://mohkale.gitlab.io/brain/20210622174949-prim_s_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174949-prim_s_algorithm/</guid><description>Is an algorithm to find a minimum spanning tree from a graph \( G \) that can work without needing to sort the data like Kruskal's algorithm.
The algorithm is:
Choose a starting vertex. Choosing a vertex (not already connected) nearest to the starting vertex and join. Choose the vertex nearest to either of the previous joined vertices and add them to the tree. Repeat step 3 until all vertices are connected.</description></item><item><title>Primary Key</title><link>https://mohkale.gitlab.io/brain/20210815020608-primary_key/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815020608-primary_key/</guid><description>Is a special [see page 5, column] in a relational database table used to uniquely identify that record.
In a situation where no suitable key can be found for a table, add a column that generates a unique key (such as GUID or just an incrementing number).</description></item><item><title>Prime Number</title><link>https://mohkale.gitlab.io/brain/20210830221840-prime_numbers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830221840-prime_numbers/</guid><description>A natural number greater than 1 that is not a product of two smaller natural numbers.
You can equivalently think of a prime-number as a number with no factors other than one and itself.
The smallest prime number is 2, then 3, then 5, 7 11, 13, 17, 19, etc.</description></item><item><title>Principle Component Analysis</title><link>https://mohkale.gitlab.io/brain/20210220191603-principle_component_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210220191603-principle_component_analysis/</guid><description>A [see page 2, method] to transform a data-set from the data space into the feature space where we have optimum dimension reduction (we can pick out the dimensions with the largest variance and drop dimensions with very little variance while losing very little information).
At a high level PCA essentially rotates our data until its spread apart as much as possible.
PCA works by creating a Feature Matrix \( F \) (from the eigenvectors of the covariance matrix) and then [see page 4, transforming] the data \( x \) with this matrix to get our new data \[ \tilde{x} = F^T x \].</description></item><item><title>Principle of Modularity</title><link>https://mohkale.gitlab.io/brain/20210626234852-principle_of_modularity/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234852-principle_of_modularity/</guid><description>[see page 34, Advocates] for weak coupling and high cohesion. That is to say:
Changes to modules should not affect other modules, and Modules should contain functions that logically belong together.</description></item><item><title>Priority Queue</title><link>https://mohkale.gitlab.io/brain/20210628055229-priority_queue/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628055229-priority_queue/</guid><description>Is a queue like data structure where each element has an associated [see page 20, priority]. The queue serves elements with a higher priority before elements with a lower priority.</description></item><item><title>Probability</title><link>https://mohkale.gitlab.io/brain/20210216031314-probability/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216031314-probability/</guid><description>A probability is a value between 0 and 1 which measures the likelihood of an event occurring. A probability of \( 0 \) means the event will never occur, and \( 1 \) means the event will definitely occur.
We define the sample-space as the list of all the outcomes for any one experiment. We define an event as a group (or set) of outcomes from an experiment. For example if the experiment is rolling a dice an event can be the dice coming up with a value greater than 4.</description></item><item><title>Probability Density Function</title><link>https://mohkale.gitlab.io/brain/20210622163642-probability_density_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622163642-probability_density_function/</guid><description>The function which describes how probabilities are allocated for the probability distribution. The sum of any probability distribution should be 1, because the sum of all the probabilities is the probability of any outcome which is always 1.
Note: It's okay to define the probability-density-function as a table containing the complete probability distribution.</description></item><item><title>Probability Distribution</title><link>https://mohkale.gitlab.io/brain/20210622163546-probability_distribution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622163546-probability_distribution/</guid><description>The set of all possible values of a random variable, together with the probability of each occurring.</description></item><item><title>Probability Tree Diagram</title><link>https://mohkale.gitlab.io/brain/20210622011346-probability_tree_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622011346-probability_tree_diagram/</guid><description>Are a way to plot the likelihood of two or more events.
The tree is a binary tree with each branch representing the two possibilities of the event happening or not. Subsequent sub-branches expand on the likelihood of separate events.
For example
The probability that it rains on any given day in march is 0.4. If it is raining the probability that tom gets a lift is 0.8 and if it is not raining the probability is 0.</description></item><item><title>Process</title><link>https://mohkale.gitlab.io/brain/20210717190151-process/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717190151-process/</guid><description>Is an instance of computer program that may be running.
Each process is allocated its own area of memory, where it can keep variables, results and even program instructions. Once the process finishes it responds with an exit status (a number in the range \( [0, 256) \)).
Memory Layout Figure 1: The layout of a program in memory (source geeksforgeeks).
When a process starts it gets its own address space including, in order, a:</description></item><item><title>Process Heap</title><link>https://mohkale.gitlab.io/brain/20211002220542-process_heap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002220542-process_heap/</guid><description>A contiguous expanding region of memory, where variables whose size cannot be determined at compile time or whose lifetime needs to be controlled manually, can be allocated. This section starts at the end of the data-segment and grows upwards. This area is also writable but not executable.
Warn: The heap can run out of memory if the system is constrained or if the program runs out of available addresses (a more common issue on 32-bit systems).</description></item><item><title>Process Stack</title><link>https://mohkale.gitlab.io/brain/20211002220418-the_stack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002220418-the_stack/</guid><description>Is part of a processes memory layout where automatically allocated variables and function call returns addresses are stored. Every time a new variable is declared the program moves the stack pointer down to reserve space for it.
This segment of the stack is writable but not executable (controlled by the NX/XOR bit) which prevents malicious code such as shellcode from being run on the stack. If the stack grows too much (exceeding a predefined limit or intersecting the heap) then program will Stack Overflow most likely resulting in a SEGFAULT.</description></item><item><title>Processor Caching</title><link>https://mohkale.gitlab.io/brain/20210930012927-cpu_caching/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210930012927-cpu_caching/</guid><description>Is the process of storing particular memory addresses in CPU registers. Operations referencing that memory address are done so in the cache and actual memory updates are deferred until later. This improves performance because the cache is quicker to access than memory (the intel I3 processor cache is roughly three times faster to reach than memory) and updating memory is slow.
Processor caching leads to the same memory being referenced in multiple places.</description></item><item><title>Processor Registers</title><link>https://mohkale.gitlab.io/brain/20210717195230-processor_registers/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717195230-processor_registers/</guid><description>Is a kind of memory available directly on a CPU.</description></item><item><title>Product</title><link>https://mohkale.gitlab.io/brain/20210621231313-product/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621231313-product/</guid><description>Is a mathematical operator like summation which instead of adding up the generated elements, multiplies them.
Commonly we use the \( \Pi \) symbol to mean product of. The position and interpretation of the fields takes the same form as summation.
For example we can define \( n \) factorial using this new notation.
\begin{align*} \prod^n_ &amp;amp;= 1 \times 2 \times 3 \times \ldots \times n \\
&amp;amp;= n! \end{align*}</description></item><item><title>Profit Margins</title><link>https://mohkale.gitlab.io/brain/20201021165748-profit_margins/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021165748-profit_margins/</guid><description>A measure of the profitability of a business. This depends on net asset turnover.
Gross Profit Margin \[ \frac{Gross Profit}{Revenue} \]
Indicates how profitable the core business is. The only expense in this calculation is the cost of sales.
A GPM of 35% means for every pound of revenue, we get 35% gross profit.
This ratio is [see page 14, quite] variable:
It depends on volatile materials (resources) Increasing market share (or finding competition) could reduce sales prices alongside the margin.</description></item><item><title>Profit Volume Graph</title><link>https://mohkale.gitlab.io/brain/20210110021747-profit_volume_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110021747-profit_volume_graph/</guid><description>An [see page 13, alternative] to the break-even-chart which follows the profits line (gradient is \(Sale Price - Variable Cost\)) through to the negative Y-axis (Y-intercept is the \(Fixed Cost\)).</description></item><item><title>Profit vs. Cash</title><link>https://mohkale.gitlab.io/brain/20210112042856-profit_vs_cash/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210112042856-profit_vs_cash/</guid><description>Profit does not equal cash, however overtime \(profit = cash\).
Cash flow simply measures the flow of cash in and out of a system, it doesn't take into account left-over inventory or non-current assets. Profit on the other hand does take these into account. See [see page 44, example].
For example:
Day 1 I buy 10 T shirts at £1.00 a shirt and sell 3 for £1.50 Day 2 I buy 2 T shirts at £1.</description></item><item><title>Program</title><link>https://mohkale.gitlab.io/brain/20210717021925-program/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717021925-program/</guid><description>Is a sequence of instructions to be executed by a computer.
A program consists of:
A binary format. This tells the OS about the various sections of the program binary, which parts are executable, constants, libraries to include, etc. A set of machine instructions. A number denoting which instruction to start from. Constants. Libraries to link and where to fill in the address of those libraries. Execution Procedure When your computer reads a program or data off the disk it:</description></item><item><title>Program Break</title><link>https://mohkale.gitlab.io/brain/20211002225849-program_break/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002225849-program_break/</guid><description>Is the first location after the end of the a processes uninitialised data-segment; essentially it determines the boundary for the heap.
You can instead the program break and effectively expand the size of the heap through the sbrk system-call. Calling sbrk(0) is a common way to find where the heap currently ends but is rarely used in user-facing code (which instead relies on memory allocators like malloc that call sbrk when required).</description></item><item><title>Programming Language</title><link>https://mohkale.gitlab.io/brain/20210718023230-programming_language/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718023230-programming_language/</guid><description>Refers to a kind of language used to write programs.</description></item><item><title>Proof by Contradiction</title><link>https://mohkale.gitlab.io/brain/20210627011306-proof_by_contradiction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627011306-proof_by_contradiction/</guid><description>Is an indirect proof that establishes the truth/validity of a proposition by positing the opposite proposition is true and then showing that such an assumption leads to a [see page 27, contradiction].</description></item><item><title>Proof by Induction</title><link>https://mohkale.gitlab.io/brain/20210622000740-proof_by_induction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622000740-proof_by_induction/</guid><description>Is a way to prove a mathematical theorem by firstly showing it holds for \( n=1 \), and then proving it holds for \( n=k+1 \) assuming it holds for \( n=k \). This shows that the property can hold for all \( n \geq 1 \) by induction.
Induction can be used to prove recurrence relations, infinite series, or divisibility.
Matrix Multiplication example For example lets suppose that if \( T^n = \begin{pmatrix} 1 &amp;amp; 1 \\ 0 &amp;amp; 1 \end{pmatrix}^n \) then \( T^{n} = \begin{pmatrix} 1 &amp;amp; n \\ 0 &amp;amp; 1 \end{pmatrix} \) for all \( n \in \mathbb{N} \).</description></item><item><title>Proper Subsets</title><link>https://mohkale.gitlab.io/brain/20210627000625-proper_subsets/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627000625-proper_subsets/</guid><description>If a set \( A \) is a subset of \( B \) but \( A \neq B \) then we say \( A \) is a proper subset of \( B \): \[ A \subset B \]</description></item><item><title>Propositional Variables</title><link>https://mohkale.gitlab.io/brain/20210626235513-propositional_variables/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626235513-propositional_variables/</guid><description>Are [see page 32, variables] used to stand for propositions in propositional logic.</description></item><item><title>Propositions</title><link>https://mohkale.gitlab.io/brain/20210626235148-propositions/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626235148-propositions/</guid><description>Sentences or expressions which are either true or false.
Can be [see page 27, subdivided] into:
Atomic Propositions: statements that can only be either true or false. For example my dog has 2 eyes. Compound Propositions: States the relationship between propositions. For example I've got black hair AND I've got brown eyes. Propositional Connectives Are the operations of propositional logic which operates on or between propositional variables. Each connective has its own semantic meaning.</description></item><item><title>Prosody</title><link>https://mohkale.gitlab.io/brain/20201026223821-prosody/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026223821-prosody/</guid><description>Using pitch, timing and loudness to [see page 9, signal] important information in speech, like punctuation or underlining in text.
These features can span over several speech segments, syllables and whole utterances.
It can be described as suprasegmental behaviour.
Lexical Stress Louder, Longer, Higher/Lower Pitch.
Basically emphasise syllables as you speak. See [see page 11, here] for a description of the affects of lexical stress, including the weaking of vowels (known as vowel centralisation/reduction).</description></item><item><title>Protocol State Machine</title><link>https://mohkale.gitlab.io/brain/20210911161623-protocol_state_machine/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911161623-protocol_state_machine/</guid><description>Is a state-machine designed to illustrate the [see page 9, protocol] of a class or interface. It shows the allowed sequence of messages and expected usage. It must depict all messages that cause a state change.</description></item><item><title>Prototype Model</title><link>https://mohkale.gitlab.io/brain/20210626214848-prototype_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626214848-prototype_model/</guid><description>Is a design model that tries to build a final solution by continually [see page 12, incrementing] on a basic prototype.
See [see page 13, advantages &amp;amp; disadvantages].
\begin{figure} \center \begin{tikzpicture}[ nd/.style={draw, rounded corners, minimum height=1cm, minimum width=3cm, fill=white}, line/.style={thick}, ] \node (com) [nd] {Communication}; \node (qp) [nd, right=of com] {Quick Plan} edge [&amp;lt;-, line] (com); \node (qd) [nd, below=of qp] {Quick Design} edge [&amp;lt;-, line] (qp); \node (pc) [nd, below left=of qd] {Prototype Construction} edge [&amp;lt;-, line] (qd); \node (dep) [nd, left=of qd] {Deployment \&amp;amp; Feedback} edge [&amp;lt;-, line] (pc) edge [-&amp;gt;, line] (com); \end{tikzpicture} \caption{The Prototyping design model.</description></item><item><title>Proxy</title><link>https://mohkale.gitlab.io/brain/20201127015247-proxy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127015247-proxy/</guid><description>Refers to a host (computer) that makes a request in place liueu of you.
We define:
Proxy Description Note Forward Proxy Proxies on behalf of client to server. Server doesn't know data has been proxied. Reverse Proxy Proxies on behalf of server to client. Client doesn't know request has been forwarded. Advantages &amp;amp; Disadvantages SSL Termination. Can decrypt requests and encrypt responses to avoid forcing this responsibility onto servers.</description></item><item><title>Pseudo Relevance Feedback</title><link>https://mohkale.gitlab.io/brain/20201025201237-pseudo_relevance_feedback/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025201237-pseudo_relevance_feedback/</guid><description>A form of relevance feedback where we [see page 10, automatically] consider the top n results for the original query as relevant.</description></item><item><title>Psuedo-random Number Generator</title><link>https://mohkale.gitlab.io/brain/20210215030824-psuedo_random_number_generator/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215030824-psuedo_random_number_generator/</guid><description>Is an algorithm to generate a series of seemingly random looking values beginning from some constrained length key \( K \) (the seed).</description></item><item><title>Public Key Cryptography</title><link>https://mohkale.gitlab.io/brain/20210429001020-public_key_cryptography/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429001020-public_key_cryptography/</guid><description>Refers to a standard for sharing secure correspondences between a sender and a recipient using asymmetric-key encryption.
Procedure [see page 24, Distribute public keys]. Assume that every involved party can access the public key of a host because it's been publicly announced somehow. You can receive better security by adding your keys to a publicly available directory or getting a certified authority to give you a key. Sign what you want to transmit with your private key.</description></item><item><title>Public or Private Law</title><link>https://mohkale.gitlab.io/brain/20201001233015-public_or_private_law/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201001233015-public_or_private_law/</guid><description>Variations of law.
Private law - Regulates the private relationship between two parties.
Public law - Concerns with public sector in undertaking its public functions.</description></item><item><title>Pure Tone</title><link>https://mohkale.gitlab.io/brain/20210128045834-pure_tone/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128045834-pure_tone/</guid><description>A sound wave with a [see page 12, sinusodial-shape].</description></item><item><title>Pytest</title><link>https://mohkale.gitlab.io/brain/20220201161507-pytest/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201161507-pytest/</guid><description>Is the standard python testing library.
Note: Pytest is an external testing framework building on the builtin unittest library. Both are described in this file for ease of reference, despite actually being two separate libraries.
Writing Tests Tests are functions that start with a test_ prefix.
Fixtures Fixtures are objects or resources that need to be shared across multiple tests in a convenient way. In pytest a fixture is a function that each test-case can accept and whose value can be initialised for the entire test suite, or for each test case.</description></item><item><title>Python</title><link>https://mohkale.gitlab.io/brain/20220201153757-python/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201153757-python/</guid><description>A modern readable and user friendly dynamically and strongly typed interpreted programming language.
Note: Newer versions of cpython compile python code into python bytecode implicitly whenever you try to run a python script. The interpreter then interprets this bytecode. This means one could classify python as a p-code language.
Pythonic A term used to describe python code follows certain stylistic and conventional guidelines.
Being Pythonic means clarity, efficiency, and credibility.</description></item><item><title>Q-learning</title><link>https://mohkale.gitlab.io/brain/20210420013530-q_learning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210420013530-q_learning/</guid><description>A [see page 11, variant] of the SARSA algorithm that instead of deferring to the policy for the future-reward action, instead always uses the greedy policy (pick the future action which maximises the reward policy).
Known as an off-policy algorithm because it doesn't depend on the policy.</description></item><item><title>Q-values</title><link>https://mohkale.gitlab.io/brain/20210414235936-q_values/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210414235936-q_values/</guid><description>We [see page 4, define] the \( Q \) value: \[ Q^{*}(s,a) = \sum_{s'} P^a_{s \longrightarrow s'} R^a_{s \longrightarrow s'} \] as the true expected reward taking an action \( a \) in a state \( s \) where:
\( P^a_{s \longrightarrow s'} \) is the probability of moving from state \( s \) to \( s' \). \( R^a_{s \longrightarrow s'} \) is the reward of moving from state \( s \) to \( s' \).</description></item><item><title>Quadrant</title><link>https://mohkale.gitlab.io/brain/20210621205429-quadrant/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621205429-quadrant/</guid><description>A sector that covers a quarter of a circle (\( 90^{\degrees} \)).</description></item><item><title>Quadratic Equation</title><link>https://mohkale.gitlab.io/brain/20210621204103-quadratic_equation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621204103-quadratic_equation/</guid><description>Is an equation of the form \( y = f(x) = ax^2 + bx + c \).
We define the roots of a equation as the values of \( x \) for which the equation equals \( 0 \). These roots are valuable because they can tell us when the line of the equation intercepts the x-axis.
The roots of a quadratic equation (and for that any equation with real-valued roots up to any power of \( x \) including cubic equations) can be factorised into a form like \( (ix+n)(jx+m) \).</description></item><item><title>Quantifications</title><link>https://mohkale.gitlab.io/brain/20210627005743-quantifications/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627005743-quantifications/</guid><description>Refers to propositions acting across sets.
Table 1: Listing of the basic laws for quantifications (see see page 11, [here]). tbl:quant-laws Name LHS RHS Negation (De Morgans) \( \neg \forall P(x) \) \( \exists x \neg P(x) \) \( \neg \exists P(x) \) \( \forall x \neg P(x) \) Equivalences \( \forall x (P(x) \land Q(x)) \) \( (\forall x P(x)) \land (\forall Q(x)) \) \( \exists x (P(x) \lor Q(x)) \) \( (\exists x P(x)) \lor (\exists Q(x)) \) \( \forall x \forall y P(x, y) \) \( \forall y \forall x P(x, y) \) \( \exists x \exists y P(x, y) \) \( \exists y \exists x P(x, y) \) Note: In regards to tbl:quant-laws not all quantifications are [see page 1, equivalent].</description></item><item><title>Quantisation</title><link>https://mohkale.gitlab.io/brain/20201102164800-quantisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102164800-quantisation/</guid><description>The [see page 2, conversion] of continuous analogue input into finite discrete bands.
This is essentially a rounding of infinite resolution values into something a computer can process without the need for infinite storage and processing.
The process of signal quantisation and sampling is often called PCM Pulse Code Modulation.
Mechanically this involves using a see page 3, counter to assign separate bits to a computer chip which the computer can then record and store.</description></item><item><title>Quefrency Domain</title><link>https://mohkale.gitlab.io/brain/20210201032932-quefrency_domain/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210201032932-quefrency_domain/</guid><description>Refers to the time-domain but through a log transform so the actual timing values are slightly off.
Note: filtering in this domain is [see page 4, known] as liftering.</description></item><item><title>Query Expansion</title><link>https://mohkale.gitlab.io/brain/20201025201349-query_expansion/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025201349-query_expansion/</guid><description>[see page 11, Expand] words in a given query prior to evaluating it. This is done to improve relevance.
For example you can:
Add synonyms Correct mispellings Swap in semantically related terms</description></item><item><title>Query Logs</title><link>https://mohkale.gitlab.io/brain/20201025204557-query_logs/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025204557-query_logs/</guid><description>The logs recorded by search engines (for each user) to analyse and improve search performance.
Recorded information [see page 49, includes]:
client IP address date, time, duration of session query terms entered by user results page returned pages viewed by user (click thru)</description></item><item><title>Queues</title><link>https://mohkale.gitlab.io/brain/20210628054020-queues/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054020-queues/</guid><description>Is a data structure where elements are queued one behind the other and you only ever have access to the element at the very beginning of the queue. Adding new elements only pushes them to the back of the queue. Think of a [see page 7, stack] as a line of people with a last in, last out policy.
Table 1: see page 8, [Operations] on queues. Method Description Enqueue(Q,x) Push element x to the tail of the queue Q.</description></item><item><title>Quick Sort</title><link>https://mohkale.gitlab.io/brain/20210622172034-quick_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622172034-quick_sort/</guid><description>Is a divide and conquer sorting algorithm re-using the core idea of transitivity from binary-search.
Formulation def quick_sort(arr, beg, end): if beg &amp;lt; end: p = partition(arr, beg, end) quick_sort(arr, beg, p - 1) quick_sort(arr, p + 1, end) def partition(beg, end, arr): &amp;#34;&amp;#34;&amp;#34;Partition all the elements of ARR such that ARR[END] is at its correct position and all the elements smaller than ARR[END] is below this position and all elements larger are after this position.</description></item><item><title>Quotient Remainder Theorem</title><link>https://mohkale.gitlab.io/brain/20210830050907-quotient_remainder_theorem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830050907-quotient_remainder_theorem/</guid><description>Is a core concept in modular arithmetic, which states:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Given any integer \\( A \\), and a positive integer \\( B \\) there exists unique integers \\( Q \\) and \\( R \\) such that: \\[ A = B \* Q + R \\; \text{where \\( 0 \leq R</description></item><item><title>Race Condition</title><link>https://mohkale.gitlab.io/brain/20211003222000-race_condition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211003222000-race_condition/</guid><description>Is a bug in multi-threaded programs where the outcome of some code is determined by the processor. I.E. It's inconsistent (non-deterministic) from one run to the next.
void *thread_main(void *p) { int *p_int = (int*) p; int x = *p_int; x += x; *p_int = x; return NULL; } int main() { int data = 1; pthread_t one, two; pthread_create(&amp;amp;one, NULL, thread_main, &amp;amp;data); pthread_create(&amp;amp;two, NULL, thread_main, &amp;amp;data); pthread_join(one, NULL); pthread_join(two, NULL); printf(&amp;#34;%d\n&amp;#34;, data); return 0; } Code Snippet 1: The canonical race condition example.</description></item><item><title>Radians</title><link>https://mohkale.gitlab.io/brain/20210621204951-radians/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621204951-radians/</guid><description>A radian is the size of the angle subtended by the arc of a circle equal to the radius. It is commonly used as an alternative to degrees for trigonometric calculations.
\begin{figure}[ht] \centering \incfig{20210611003853} \caption{Demonstration of the relation between one radian and the circumference of the circle.} \end{figure} \begin{align} \pi^c &amp;amp;= 180^{\degree} &amp;amp; 1^c &amp;amp;= \frac{180^{\degree}}{\pi} \approx (57.3)^{\degree} &amp;amp; 1^{\degree} &amp;amp;= \frac{\pi^c}{180} \approx 1.75 \times (10{-2})c \end{align}</description></item><item><title>Radix Sort</title><link>https://mohkale.gitlab.io/brain/20210628053847-radix_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053847-radix_sort/</guid><description>Is a linear time sorting algorithm which sorts a series of numbers by sorting based on individual digits. When using a stable sorting algorithm to sort on [see page 19, individual digits] you can guarantee the output is properly sorted.
def radix_sort(arr): d = max(len(str(i)) for i in arr) for i in range(0, d): stable_sort(arr, i) Code Snippet 1: Implementation of radix sort to sort each digit using some stable sorting algorithm.</description></item><item><title>RAID</title><link>https://mohkale.gitlab.io/brain/20210816192340-raid/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210816192340-raid/</guid><description>The employment of [see page 16, multiple] hard disks together to provide data redundancy (backups).
Table 1: Listing of the various levels of the RAID architecture. Level Description RAID-0 Data is stripped (segmented) across different disks. RAID-1 Mirror copy of data is also made across different disks. RAID-2 Error correcting codes also retained on different disks. For RAID-1 If one disk fails then we still have the same data available on another disk, until that data can be cloned to a new backup disk as well.</description></item><item><title>Random Access Model</title><link>https://mohkale.gitlab.io/brain/20210628050321-random_access_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628050321-random_access_model/</guid><description>A generic random-access machine where instructions are executed one after another with no concurrent operations. This model is often used to argue and reason about the behaviour of an algorithm including its runtime complexity.</description></item><item><title>Random Algorithms</title><link>https://mohkale.gitlab.io/brain/20210628053233-random_algorithms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053233-random_algorithms/</guid><description>An algorithm employing some [see page 27, randomness]. For example randomised quick-sort.
The advantage of randomised algorithms is that behaviour is consistent across all inputs, but the runtime of the algorithm isn't fixed from one invocation to the next.</description></item><item><title>Range</title><link>https://mohkale.gitlab.io/brain/20210626025249-range/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626025249-range/</guid><description>The set of outputs for a function. \[ \text{range}(f) = \{ f(a) : a \in \text{domain}(f) \} \]</description></item><item><title>Ranked Algorithms</title><link>https://mohkale.gitlab.io/brain/20201014222724-ranked_algorithms/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201014222724-ranked_algorithms/</guid><description>An information retrieval model which consider every document as relevant (as opposed to the boolean retrieval model) and tries to order documents by the degree of relevance to the search query.
Different [see page 28, implementations] of the ranked model include:
Vector Space Model (SMART) Probabilistic Model (OKAPI) Web Search Engines (Page Rank)</description></item><item><title>Ratio Analysis</title><link>https://mohkale.gitlab.io/brain/20201021163342-ratio_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021163342-ratio_analysis/</guid><description>Comparison of a companies market share, unsold stock, or other possible assets or non-tangible values with other companies.
A ratio by itself is only useful when looking at the reasons for how/why a ratio changes. eg. Gross profit margin up 20%, why? Profit Ratios Profit ratio measures include:
Profit Margins Return on Capital Employed Efficiency Ratios [see page 22, Includes]:
Inventory holding period Trade receivables collection period Trade payables payment period Solvency Ratios liquidity-ratio Acid Test Ratio Investment Ratios See [see page 3, here].</description></item><item><title>Rational Agent</title><link>https://mohkale.gitlab.io/brain/20210926212542-rational_agent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926212542-rational_agent/</guid><description>Is an agent that [see page 24, acts] to achieve the best outcome or when there is uncertainty the best expected outcome. That is an agent that behaves rationally.
Rational agents use a performance measure which given a sequence of environment states, evaluates how good they are. A sequence of states for a cleaning robot may observe the robot is staying in the same clean square forever and give it a low score to indicate it should explore a bit.</description></item><item><title>Rationality</title><link>https://mohkale.gitlab.io/brain/20210926212837-rationality/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926212837-rationality/</guid><description>We define [see page 24, rationality], right thinking, as doing the right thing given what information is known by the agent.
Rationality involves both logical inferences (natural deduction) and non-inferential decision making. One way to act rationally is reason logically on the outcomes of actions with respect to ones goals and pick the actions that maximise your rewards or reaches your desired outcomes. Alternatively some rational actions are reflexive. For example recoiling from a hot-stove is a reflex that are often more effective than a slower action after careful deliberation.</description></item><item><title>Ray Box Intersection</title><link>https://mohkale.gitlab.io/brain/20210106002622-ray_box_intersection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106002622-ray_box_intersection/</guid><description>A [see page 13, way] of detecting the intersection between a box and a line.
Uses each corner of the box to define two planes and then for each pair of planes we calculate where the line intersects that each plain. Then there's an equation we can use to detect whether the line intersected the box depending on the largest and smallest value of each intersection to each plain.</description></item><item><title>Ray Casting</title><link>https://mohkale.gitlab.io/brain/20210105023955-ray_casting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210105023955-ray_casting/</guid><description>Is an alternative for the rendering-pipeline which [see page 4, sends] a line from the eye to each pixel in the world and the closest objects pixel which intersects that ray is shown first.
Note: We send from the eyes because most light doesn't reach the eye and we only care about the light that's visible. If we instead sent rays from the object and only measured the contribution from the rays that intersect the eye then there would be a lot of wasted calculations.</description></item><item><title>Ray Plane Intersection</title><link>https://mohkale.gitlab.io/brain/20210106001739-ray_plane_intersection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106001739-ray_plane_intersection/</guid><description>A [see page 9, way] to detect whether a line intersects some infinite plane (surface).</description></item><item><title>Ray Polygon Intersection</title><link>https://mohkale.gitlab.io/brain/20210106001842-ray_polygon_intersection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106001842-ray_polygon_intersection/</guid><description>A [see page 10, way] to detect whether an arbitrary polygon intersects a ray.
This works by first forming a plane from the polygon (using it's vertices and the polygon normal) and then using ray-plane-intersection and asserting that the intersection point is in the polygon (using [see page 11, barycentric-coordinates]).
We can also calculate the [see page 12, normal] at the intersection point using a combination of each vertex normals.</description></item><item><title>Ray Sphere Intersection</title><link>https://mohkale.gitlab.io/brain/20210106000059-ray_sphere_intersection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106000059-ray_sphere_intersection/</guid><description>A [see page 6, way] to detect whether a sphere intersects a line.
There's the classic [see page 7, algebraic] approach (trying to solve for the roots of a quadratic formula) but also the slightly quicker [see page 8, geometric] approach which finds the line perpendicular to the ray and going through the centre of the circle and then asserts whether it's within the bounds of the radius.</description></item><item><title>Ray Tracing</title><link>https://mohkale.gitlab.io/brain/20201109195409-ray_tracing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109195409-ray_tracing/</guid><description>A way to [see page 3, simulate] the lighting in a room by projecting rays from the eye-holder which bounce between different objects/materials until they meet with a light- source.
Optimisations We've explored several intersection algorithms:
Ray Plane Intersection Ray Box Intersection Ray Sphere Intersection Ray Polygon Intersection But all of these involve a lot of calculations and are difficult to [see page 14, scale]. Various optimisation techniques include:</description></item><item><title>Reactive Systems</title><link>https://mohkale.gitlab.io/brain/20210910202406-reactive_systems/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210910202406-reactive_systems/</guid><description>Describes a [see page 3, system] that exists in one of several states and exhibits different behaviours in each state. The same action when done under different states may trigger different reactions.
Such systems respond to events in different ways depending on the current state. For example a vending machine that ignores drink dispensing buttons until enough coins have been dispensed.
Table 1: Terms used to describe reactive systems. Term Description Events Requests which are handled by the system.</description></item><item><title>Reader Writer Problem</title><link>https://mohkale.gitlab.io/brain/20211007030900-reader_writer_problem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211007030900-reader_writer_problem/</guid><description>Is a problem in multi-threaded systems where we want to allow multiple threads read-access to a data-store (example a HashMap) but we want to only allow one thread to write to the store and block other threads from reading while it's being written to.
int writers; // Number writer threads that want to enter the critical section (some or all of these may be blocked) int writing; // Number of threads that are actually writing inside the critical section (can only be zero or one) int reading; // Number of threads that are actually reading inside the critical section // if writing !</description></item><item><title>Reason</title><link>https://mohkale.gitlab.io/brain/20210626235122-reason/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626235122-reason/</guid><description>The capacity for making [see page 23, sense] of things, establishing and verifying facts and changing or justifying practices and beliefs based on new or existing information.
In science, logic means the study of valid reasoning.</description></item><item><title>Receptive Field</title><link>https://mohkale.gitlab.io/brain/20210301032506-receptive_field/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210301032506-receptive_field/</guid><description>A portion of sensory space that can elicit neuronal responses (in the [see page 5, visual] pathway) when stimulated. Essentially when we have a screen with some stimulus (light) being shone on it then certain neurons will respond quite strongly when stimuli are in certain positions or coming from certain directions.
In the Visual Pathway Receptive fields can be devided into categories depending on how deep into the visual pathway their found.</description></item><item><title>Recession</title><link>https://mohkale.gitlab.io/brain/20201106012137-recession/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106012137-recession/</guid><description>When the gross-domestic-product of a country/economic-area decreases for at least 2 consecutive quarters (6 months).</description></item><item><title>Rectangular Hyperbola</title><link>https://mohkale.gitlab.io/brain/20210621235913-rectangular_hyperbola/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621235913-rectangular_hyperbola/</guid><description>Is a hyperbola with vertical asymptotes. For a parabola \( \frac{\,dy}{\,dx} \) is always \( - \frac{1}{t^2} \).
\begin{figure} \centering \begin{tikzpicture} % preamble \usepackage{amsmath} %\draw[gray!50, very thin,-&amp;gt;] (-4,0) -- (4,-0); % x-axis %\draw[gray!50, very thin,-&amp;gt;] (0,-3) -- (0,3); % y-axis %\draw[gray!50, very thin] (-2,-1.5) rectangle (2,1.5); \draw[black, ultra thick, -&amp;gt;] (0, -3) -- (0, 3) node[left]{$y$}; \draw[black, ultra thick, -&amp;gt;] (-3.5, 0) -- (4, 0) node[below]{$x$}; \draw[very thin, gray!</description></item><item><title>Recurrence Relation</title><link>https://mohkale.gitlab.io/brain/20210621215918-recurrence_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621215918-recurrence_relation/</guid><description>An equation that recursively defines a sequence of values. For example \[ x_{n+1} = \frac{x_n^5+3}{5} \]
Often these relations specify an initial value for \( x_0 \) and lets you calculate subsequent values.</description></item><item><title>Recursive Definition</title><link>https://mohkale.gitlab.io/brain/20210627015940-recursive_definition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627015940-recursive_definition/</guid><description>A [see page 4, recursive] definition is one which uses the word or concept being defined in the definition itself. For example consider the recursive sequence of powers of 2 defined as \begin{align*} a_0 &amp;amp;= 1 &amp;amp; an+1 = 2a_n \qquad n &amp;ge; 0 \end{align*}.
Any function with a domain of the natural numbers can be [see page 8, defined] recursively by specifying the value of the function at zero and then giving a rule for finding its value at any integer in terms of values at smaller integers.</description></item><item><title>Reducing the Footprint</title><link>https://mohkale.gitlab.io/brain/20210415005452-reducing_the_footprint/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415005452-reducing_the_footprint/</guid><description>Tries to hide or minimise the visible [see page 23, disruption] to a system leading up to an attack, such as to make it harder to follow where it came from or who was responsible.
Approaches [see page 24, Memory Injection] Code is directly injected into the memory and there's no trace in the file-system. This can happen by exploiting a buffer-overflow.
Another approach to this is Userland Exec where you start a program and then overwrite the instructions of the program by writing another program in-its place.</description></item><item><title>Refactoring</title><link>https://mohkale.gitlab.io/brain/20210626231808-refactoring/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626231808-refactoring/</guid><description>Any change to a computer program's code which improves its readability or simplifies its structure without changing its results.
[see page 32, COM1001 W03 Agile] What distinguishes refactoring from developing is that the underlying functionality of the refactored code must remain the same.</description></item><item><title>Reflexive Relation</title><link>https://mohkale.gitlab.io/brain/20210627012250-reflexive/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627012250-reflexive/</guid><description>A homogeneous relation \( R \) is [see page 17, reflexive] if and only if \( \forall x \in A (x R x) \). For example \( \leq \) is a reflexive relation, however \( &amp;lt; \) is irreflexive.</description></item><item><title>Reinforcement Learning</title><link>https://mohkale.gitlab.io/brain/20210206035521-reinforcement_learning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206035521-reinforcement_learning/</guid><description>A category of learning algorithms that rewards or punishes actions to reinforce beneficial [see page 15, behaviour]. Consider a game, at each point in time the game is in some state and the system can perform some action to move it to a new state. Learning the actions that lead to a good outcome (maximise reward) is how reinforcement learning works.
The goal of reinforcement learning is:
Updating the parameters so that the total reward is maximised.</description></item><item><title>Reinforcement Neural Network</title><link>https://mohkale.gitlab.io/brain/20210420012233-reinforcement_neural_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210420012233-reinforcement_neural_network/</guid><description>Is a class of reinforcement learning algorithms using neural networks.
Formulation Formulated by [see page 6, encoding] our state in our pre-synaptic neurons and the actions we can take as the post-synaptic neuron. We can then define \[ Q(s,a) = w_a x \] as the [see page 4, rate of postsynaptic return], where \( w_a \) is the weight vector connecting the current state to the action neuron \( a \).</description></item><item><title>Relation Composition</title><link>https://mohkale.gitlab.io/brain/20210627014548-relation_composition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627014548-relation_composition/</guid><description>For a relation \( R \subseteq A \times B \) and \( S \subseteq B \times C \) we define the [see page 11, composition] of \( S \) and \( R \) as \( S \circ R \subseteq A \times C \) where \( S \circ R = \{ (a, c) : \exists b \in B ((a, b) \in R \land (b, c) \in S) \} \).</description></item><item><title>Relation Extraction</title><link>https://mohkale.gitlab.io/brain/20201210185138-relation_extraction/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201210185138-relation_extraction/</guid><description>Identify the relationships between pairs of (pre-identified) entities. Eg. &amp;quot;Both these organisations are in the same town&amp;quot;, &amp;quot;this organ supports this body part&amp;quot;, &amp;quot;FOO is an employee in ORG&amp;quot;.
We [see page 7, define] R as the set of possible (assumed binary) relations between entities (which're a subset of those identified in the entity extraction stage).
This task is decomposed into:
Task Meaning Relation detection Find pairs of entities between which a relation holds.</description></item><item><title>Relational Database</title><link>https://mohkale.gitlab.io/brain/20210815015504-relational_database/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815015504-relational_database/</guid><description>Is a database system [see page 4, model] designed to eliminate redundancy of stored information and minimise the dependency between data items.
Logically a relational database presents a set of tables indexed as row \( \times \) column. Each row is a record, or unique entity, in the table. Each column is a field tied to the record.
Table 1: Example of a database table with 3 records and 4 fields.</description></item><item><title>Relative Refactory Period</title><link>https://mohkale.gitlab.io/brain/20210206062418-relative_refactory_period/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206062418-relative_refactory_period/</guid><description>After a spike in potential in a neuron the curve of potential will reach negative value, to make it harder to induce another spike for a brief period. Essentially to avoid spamming excitations .</description></item><item><title>Relevance Feedback</title><link>https://mohkale.gitlab.io/brain/20201025200703-relevance_feedback/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025200703-relevance_feedback/</guid><description>Ways to improve the relevance of a query based on user feedback.
For example:
User inputs query. Show some documnets. Ask which documents their interested. Automatically reform query to better represent the relevant documents. Show more documents. This concept is represented mathematically [see page 9, here]. Using a vector representation we offset the document position in vector-space by a weighted average of irrelevent and relevant documents to skew the results and better represent the users target documents area.</description></item><item><title>Remainder Theorem</title><link>https://mohkale.gitlab.io/brain/20210621225511-remainder_theorem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621225511-remainder_theorem/</guid><description>States that if we divide a polynomial \( f(x) \) by a linear term \( x - a \) the remainder of the fraction \( \frac{f(x)}{x - a} = f(a) \). Furthermore if \( x - a \) is a factor of \( f(x) \) then \( f(a) = 0 \).
Note: A linear term is any term with the highest power of \( x \) being 1.</description></item><item><title>Remote Procedure Call</title><link>https://mohkale.gitlab.io/brain/20211010155408-remote_procedure_call/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010155408-remote_procedure_call/</guid><description>Is the idea of calling a procedure on a different machine. In practice the procedure can also be run on the same but in a different context (such as a different user or file-system jail).
Warn: A secure RPC will need to implement additional security checks including authentication and authorisation.
The key values of RPC are:
Privilege Separation: The procedure can run with different (lower or higher) privileges to the caller.</description></item><item><title>Requirements Analysis</title><link>https://mohkale.gitlab.io/brain/20210626233421-requirements_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626233421-requirements_analysis/</guid><description>Is the [see page 15, process] of studying user needs to arrive at definitions of system, hardware or software requirements.
This is related to threat modelling.
This involves:
[see page 16, Inception]: Identify stakeholders, recognise multiple viewpoints, Q&amp;amp;A. A [see page 17, stakeholders] can be: Persons or organisations who have a valid interest in (or are affected by) the system. Anyone who operates the system. Anyone who benefits from the system.</description></item><item><title>Requirements Engineering</title><link>https://mohkale.gitlab.io/brain/20210626232937-requirements_engineering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626232937-requirements_engineering/</guid><description>Is the process of eliciting [see page 4, requirements] for a project where we convert the real world requirements of the project into a description of what the system should do (not how).
The hardest single part of building a software system is deciding what to build. No part of the work so cripples the resulting system if done wrong. No other part is more difficult to rectify later.</description></item><item><title>Resonance</title><link>https://mohkale.gitlab.io/brain/20201115214852-resonance/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201115214852-resonance/</guid><description>Refers to the phenomenon where when an object is set to vibrate at its natural-frequency any nearby objects with the same natural-frequency is also made to vibrate (very easily).
Acoustic enclosures have resonant features dependent on their:
physical dimensions surface reflection properties</description></item><item><title>Resource Allocation Graph</title><link>https://mohkale.gitlab.io/brain/20211008011636-resource_allocation_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008011636-resource_allocation_graph/</guid><description>Tracks which resources is held by which process and which process is waiting for a resource of a particular type. If a process is using a resource an arrow is drawn from it to the process node. If a process is requesting a resource an arrow is drawn from its process node to the resource.
If there is a cycle in the Resource Allocation Graph and each resource in the cycle and each resource in the cycle provides only one instance then the process will deadlock.</description></item><item><title>REST</title><link>https://mohkale.gitlab.io/brain/20201128165048-rest/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201128165048-rest/</guid><description>An approach for creating RPC interfaces based on statelessness and clean permalinks.
Statelessness means that requests are performed in isolation. Each requests carries all the information needed to perform that action, the server doesn't have to maintain some sort of memory about earlier requests.
See Debunking the Myths of RPC &amp;amp; REST.</description></item><item><title>Return on Capital Employed</title><link>https://mohkale.gitlab.io/brain/20201021164921-roce/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021164921-roce/</guid><description>[see page 10, Represents] operating profit as a percentage of the long term funds invested in the business.
\(\mathrm{ROCE} = \frac{\mathrm{Operating Profit}}{\mathrm{Equity Funds} + \mathrm{Non Current Liabilities}}\)
This measure shows the effectiveness of the company in employing long term funds.
Note: ROCE can [see page 19, also] be calculated as Operating Profit Margin \(\times\) Net Asset Turnover.</description></item><item><title>Reverberation</title><link>https://mohkale.gitlab.io/brain/20201127210325-reverberation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127210325-reverberation/</guid><description>Occurs in large hard rooms/areas where sound reflects a lot degrading it's quality.</description></item><item><title>Reward Policy</title><link>https://mohkale.gitlab.io/brain/20210415000715-reward_policy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415000715-reward_policy/</guid><description>Refers to the [see page 12, algorithm] we use to decide which action to take to maximise our reward in a decision problem. Policies are often defined using an adaption of Q-values.
Exploration vs. Exploitation The [see page 11, goal] of a policy isn't simply maximising reward but also to explore other possibly sub-optimal actions in the hopes of discovering a more optimal actions in the long run.
The environment of problems are generally stochastic and complex, at the beginning of the process we do not know the Q-value and must estimate them by exploring.</description></item><item><title>Ring Buffer</title><link>https://mohkale.gitlab.io/brain/20211007032111-ring_buffer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211007032111-ring_buffer/</guid><description>Is a queue like data-structure that uses a single fixed-size buffer as if it were connected end to end. We maintain pointers both to the start and end of the buffer and move along the ring while inserting elements, wrapping back around at either end. We also maintain pointers to the effective start and end of the buffer (excluding elements that have been popped or deleted).
The ring buffer is a good FIFO data-structure.</description></item><item><title>Rod Cutting Problem</title><link>https://mohkale.gitlab.io/brain/20210628054856-rod_cutting_problem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054856-rod_cutting_problem/</guid><description>Is a [see page 9, problem] where we have to cut a steel rod of length \( n \) into pieces in order to maximise revenue from selling all the pieces. The cost of each cut is free, rod lengths are an integral number of cm and each rod length \( i \) has its own price.
Rod Cutting Solution example Table 1: Table of rewards for cutting each rod of length \( i \).</description></item><item><title>Rogue</title><link>https://mohkale.gitlab.io/brain/20210211224900-rogue/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211224900-rogue/</guid><description>A [see page 4, command] that performs its usual functions (trojans) but also modifies DAC permissions on all the subjects files.</description></item><item><title>Rogue Certificate</title><link>https://mohkale.gitlab.io/brain/20210429004350-rogue_certificate/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429004350-rogue_certificate/</guid><description>Refers to a network certificate that's been compromised, revoked or otherwise invalidated.
These certificates are often [see page 41, kept] in Certificate Revocation Lists (CRLs) by a certifying authority.</description></item><item><title>Role Based Access Control</title><link>https://mohkale.gitlab.io/brain/20210211222859-role_based_access_control/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211222859-role_based_access_control/</guid><description>An ACM that [see page 27, decouples] and separates users and permissions by using an intermediate representation of a role.
Users are granted privileges based on their roles, for example a lecturer can add students to his class, a student can get through security gates to reach lecture rooms. These privileges are given to the role of a student, independent of the exact student in question.
We [see page 28, define]:</description></item><item><title>ROM</title><link>https://mohkale.gitlab.io/brain/20210811040054-rom/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811040054-rom/</guid><description>Read Only Memory.</description></item><item><title>ROT13</title><link>https://mohkale.gitlab.io/brain/20210215021847-rot13/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215021847-rot13/</guid><description>An application of the caesar cipher which uses a fixed offset of 13.</description></item><item><title>Rotoscoping</title><link>https://mohkale.gitlab.io/brain/20201124161305-rotoscoping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201124161305-rotoscoping/</guid><description>Animation based on taking a series of pictographic images and drawing images on top of them.
Basically using real-images as templates for animated sequences.</description></item><item><title>Round Robin Scheduler</title><link>https://mohkale.gitlab.io/brain/20211009142621-round_robin_scheduler/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009142621-round_robin_scheduler/</guid><description>Is a scheduling algorithm that schedules processes in order of their arrival in the queue, and then forcibly removes processes from the running state and back into the ready queue after a small time step.
The maximum amount of time that a process can execute before being stopped is called the Time Quanta. Note: As the time quanta approaches infinity, the round robin scheduler will be equivalent to a FCFS scheduler.</description></item><item><title>Route Inspection Problem</title><link>https://mohkale.gitlab.io/brain/20210623023704-route_inspection_problem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210623023704-route_inspection_problem/</guid><description>Is the problem of traversing a graph \( G \) such that you cover every edge in the graph once and then return to your start point.
The algorithm for this has us convert a non-traversable network into a traversable one by repeating one or more edges on an odd node to ensure it has an even valency (making the graph eulerian).
The algorithm is:
List all odd vertices. Form all possible pairings of odd vertices.</description></item><item><title>Router</title><link>https://mohkale.gitlab.io/brain/20210428234156-router/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428234156-router/</guid><description>Is a device operating at layer 3 of the OSI Model. They serve two functions:
Create and maintain a map of the devices in the local area network. Manage the data entering, leaving and moving within the network. Routers are smart enough to measure the time it takes for a packet to reach another router and use this information to direct packets over fast links. If a router drops off a network the other routers can detect and circumvent the failed router.</description></item><item><title>RPM</title><link>https://mohkale.gitlab.io/brain/20220228155915-rpm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220228155915-rpm/</guid><description>Is the standard package format for Redhat Linux systems.</description></item><item><title>RSA</title><link>https://mohkale.gitlab.io/brain/20210826003538-rsa/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210826003538-rsa/</guid><description>Is a algorithm for Asymmetric-key Encryption.
It's named for its [see page 14, inventors]: Ron Rivest, Adi Shamir, Len Adleman.
Procedure Key Generation First we pick two large primes \( pq \). The product of these primes \( n = pq \) will be half of our public key. Then we calculate the Euler totient of \( n \) as \( \Phi(pq) = pq (1 - \frac{1}{p}) (1 - \frac{1}{q}) = (p - 1) (q - 1) \) and choose a number \( e \) which is relatively prime to \( \Phi(pq) \) as the other half of our public key.</description></item><item><title>Runtime Performance</title><link>https://mohkale.gitlab.io/brain/20210628050058-runtime_performance/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628050058-runtime_performance/</guid><description>Is a measure of the performance of an algorithm.
This can take several approaches from the runtime (operation count), [see page 21, comparisons] between elements, additional space (memory), or any other metric that can be used to evaluate an algorithm.</description></item><item><title>Runtime Recurrence Relations</title><link>https://mohkale.gitlab.io/brain/20210628052459-runtime_recurrence_relations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628052459-runtime_recurrence_relations/</guid><description>Some time-complexity calculations form as recurrence-relations, for [see page 13, example]:
\begin{align} T(n) &amp;amp;=
\begin{cases} \theta(1) &amp;amp; \text{if \\( n = 2^0 = 1 \\)} \\\\ 2T(\frac{n}{2}) + \theta(n) &amp;amp; \text{if \\( n = 2^k \\) for \\( k \geq 1 \\)} \end{cases} \end{align}
These can be solved in 3 ways: substitution method, recursion tree, master theorem.
Substitution Method Involves guessing a solution for the time-complexity and then verifying through induction.</description></item><item><title>S-box</title><link>https://mohkale.gitlab.io/brain/20210216005256-s_box/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216005256-s_box/</guid><description>Is a [see page 26, box] used in a cryptographic system which performs the role of substitution cipher. It replaces one block of bits with another block, that could contain a different number of 0s or 1s than the input block.
A substitution box can be seen as a very simple block cipher.
These are often implemented as a [see page 3, lookup-table], an exhaustive list of possible inputs with possible outputs, however for suitably large S-Boxes this quickly becomes infeasible.</description></item><item><title>S-Plane</title><link>https://mohkale.gitlab.io/brain/20201117003324-s_plane/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201117003324-s_plane/</guid><description>The z-plane equivalent for the [see page 9, laplacian] domain.</description></item><item><title>Sampling</title><link>https://mohkale.gitlab.io/brain/20201105142051-sampling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201105142051-sampling/</guid><description>The [see page 6, process] of picking a color for a pixel on an objects surface from a texture map.
Textures are mapped into a coordinate-space with \((0,0)\) in the bottom left and \((1,1)\) in the top right. If we specify a texture coordinate outside of this range, OpenGl supports a few options for what to do:
Term Meaning GL_REPEAT (default) Repeat the texture.</description></item><item><title>Sampling</title><link>https://mohkale.gitlab.io/brain/20210130020434-sampling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210130020434-sampling/</guid><description>quantisation in the time domain.
The interval between sampling speech signals is the sampling frequence. These often used [see page 5, fixed] values depending on the domain, however to get an accurate sample it's recommended to use at least twice the maximum signal frequency.
We can do this using a [see page 7, dirac-delta] function.</description></item><item><title>SARSA Algorithm</title><link>https://mohkale.gitlab.io/brain/20210420012449-sarsa_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210420012449-sarsa_algorithm/</guid><description>A reinforcement neural network algorithm which considers future-rewards.
Note: SARSA is an abbreviation for State-&amp;gt;Action-&amp;gt;Reward-&amp;gt;State-&amp;gt;Action.
Think two steps ahead to win one step in advance.
TODO: Mention why future-rewards are needed, because the reward from an action could be 0 with the classic formulation above leading to a 0 value for \( \Delta{Q} \) meaning \( Q \) will never change if the initial \( Q \) values are 0.</description></item><item><title>Sashimi Waterfall</title><link>https://mohkale.gitlab.io/brain/20210626202010-sashimi_waterfall/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626202010-sashimi_waterfall/</guid><description>Is a variant of the waterfall model where every phase can [see page 39, feedback] to every other phase.
\begin{figure} \center \begin{tikzpicture}[ nd/.style={draw, rounded corners, minimum height=1cm, minimum width=3cm, fill=white}, line/.style={thick}, ] \node (req) [nd] {Requirements}; \node (design) [nd, below right=-0.5cm of req] {Design}; \node (imp) [nd, below right=-0.5cm of design] {Implementation}; \node (ver) [nd, below right=-0.5cm of imp] {Verification}; \node (dep) [nd, below right=-0.5cm of ver] {Deployment}; \node (maintenance) [nd, below right=-0.</description></item><item><title>Saturation</title><link>https://mohkale.gitlab.io/brain/20210216050413-saturation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216050413-saturation/</guid><description>Is a property of a function which means that the output value is asymptotically approaching 0 or 1 as the input goes to -infinity and +infinity respectively. That is, if the input is already large then increasing the input slightly will change the output by only a small amount compared to region close to 0.
For a numerical example:
If \(h = 0\), then \(sigmoid(0) = 0.5\), increasing the input by 1 gives \(sigmoid(1) = 0.</description></item><item><title>Scalability</title><link>https://mohkale.gitlab.io/brain/20201127014147-scalability/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127014147-scalability/</guid><description>Refers to the ability of a system to scale. What this means is that the performance of the system increases in a manner proportional to the resources added to it.
We can define performance as serving more units of work, but it can also be handling larger units of work (such as when datasets grow).
If you have a performance problem, your system is slow for a single user. If you have a scalability problem, your system is fast for a single user but slow under heavy load.</description></item><item><title>Scatter Diagram</title><link>https://mohkale.gitlab.io/brain/20210622164950-scatter_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622164950-scatter_diagram/</guid><description>Are a way to visualise and compare sets of paired data.
We put the *independent*/explanatory variable (what we change during the experiment) on the \( x \)-axis and the *dependent*/response variable (what we measured from the experiment) on the \( y \)-axis.</description></item><item><title>Scenario</title><link>https://mohkale.gitlab.io/brain/20210911022157-scenario/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911022157-scenario/</guid><description>A [see page 21, scenario] is a complete path through a use-case, a specific sequence of actions and interactions between actors (where at least one actor is a system) from beginning to end.</description></item><item><title>Scene Graph</title><link>https://mohkale.gitlab.io/brain/20201002220923-scene_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201002220923-scene_graph/</guid><description>A [see page 20, graph] representing objects in a 3d-scene.
Leaves should be specific shapes plopped at the origin, then as we go up the graph we [see page 13, apply transformations] at each node to the scene that's being incrementally built, with each transformation being represented as explicit nodes in the scene graph. This has the affect of applying the same transformation to each child of that node in such a way that the transformation appears to be hinged at that point.</description></item><item><title>Scheduler</title><link>https://mohkale.gitlab.io/brain/20210717192205-scheduler/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717192205-scheduler/</guid><description>Is a component of the kernel that oversees timesharing.
The scheduler tracks information about all the other (non-kernel) processes on your machine. Every 1/\nth{60} of a second a timer goes off triggering a clock interrupt which causes the scheduler to stop whatever process is currently running, suspend it in place and hand control to another process. In practice 1/\nth{60} of a second on modern hardware allows for tens of thousands of instructions to be run by each process.</description></item><item><title>Scheduling</title><link>https://mohkale.gitlab.io/brain/20211009013427-scheduling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009013427-scheduling/</guid><description>Is the problem of deciding which process gets to run on which CPU core at a given time. Its the main job of the scheduler. The balancing problem of scheduling is that you want to stop processes often enough to have a responsive computer (a process freezing when you interact with it cause it currently doesn't have the CPU is bad) but you don't it to happen so often that processes are spending inordinate amounts of time context switching.</description></item><item><title>Scintillation</title><link>https://mohkale.gitlab.io/brain/20201109160308-scintillation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109160308-scintillation/</guid><description>The [see page 4, affect] where small objects can disappear entirely or break up unpredictably when being sampled at too small a resolution.</description></item><item><title>Screen Extents</title><link>https://mohkale.gitlab.io/brain/20210106004154-screen_extents/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106004154-screen_extents/</guid><description>A ray-tracing intersection [see page 18, optimisation-technique] which projects all objects onto the screen and then only ray-tracing objects within a certain projection extent/distance from this screen.
This generally only helps for simple scenes with few distinct objects.</description></item><item><title>SCRUM</title><link>https://mohkale.gitlab.io/brain/20210626232614-scrum/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626232614-scrum/</guid><description>Is an agile development process that works using small self-organising [see page 4, teams] of roughly 5-9 people from various disciplines.
The SCRUM Team A typical SCRUM team includes a:
[see page 5, Product owner]: Typically a product manager (who can also be a developer). This person defines the features of the product, the release date and content. They prioritise features for each iteration and judge whether to accept or reject a developers work.</description></item><item><title>search</title><link>https://mohkale.gitlab.io/search/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/search/</guid><description>clear 'use-strict'; let form = document.getElementById('site-search'), text = document.getElementById('search-input'); text.addEventListener('focus', function() { form.classList.add('active'); }) text.addEventListener('blur', function() { form.classList.remove('active'); })</description></item><item><title>Search Algorithm</title><link>https://mohkale.gitlab.io/brain/20210622171407-search_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622171407-search_algorithm/</guid><description>An algorithm to find whether an element exists in an array/collection.</description></item><item><title>Sector and Segment</title><link>https://mohkale.gitlab.io/brain/20210621205257-sector_and_segment/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621205257-sector_and_segment/</guid><description>An arc is a section of the circumference of the circle A sector is an area enclosed by two radii and an arc A chord is a straight line connecting two points on the circumference of a circle A segment is a section formed between an arc and a chord \begin{figure}[ht] \centering \incfig{20210609175724} \caption{Annotation of a circle with both a segment and a sector.} \end{figure} Sector Area \begin{align} \label{eq:sector-area-radians} a = \frac{r^2 \theta^{c}}{2} \end{align}</description></item><item><title>Secure SDLC</title><link>https://mohkale.gitlab.io/brain/20210430002356-secure_sdlc/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430002356-secure_sdlc/</guid><description>Refers to software development life cycles which [see page 7, help] developers build more secure, less costly and security compliant software solutions.
Can be thought of as a game with [see page 7, two] players, The:
Defender trying to avoid, find and fix vulnerabilities, and the Adversary/attacker trying to find and exploit one (or more) vulnerabilities. Note: Previously hackers were motivated be fun (I.E. prestige). Nowadays it's more for profit, politics, goal-oriented.</description></item><item><title>Securities</title><link>https://mohkale.gitlab.io/brain/20220228173835-securities/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220228173835-securities/</guid><description/></item><item><title>Security Attack</title><link>https://mohkale.gitlab.io/brain/20210211053806-security_attack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211053806-security_attack/</guid><description>An attack or vulnerability on a digital system. A threat can [see page 58, target] a computer network, a host or an application.
There aren't any straightforward and guaranteed ways to prevent software attacks. We have no [see page 18, silver bullets]. Security is never 100%, the most we can do is reduce risk and we should instead consider non-functional security aspects from the start of a design.
Note: Malicious hackers don't create security holes, they simply [see page 17, exploit] them.</description></item><item><title>Security Constraints</title><link>https://mohkale.gitlab.io/brain/20210906005928-security_constraints/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906005928-security_constraints/</guid><description>Constraints related to the integrity of the data passing through the information:
Confidentiality, distribution and encryption of data. Personal authorisation and access to the rights of data. Robustness, recovery, protection of data.</description></item><item><title>Security Protocol</title><link>https://mohkale.gitlab.io/brain/20210428235750-security_protocol/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428235750-security_protocol/</guid><description>We define security protocol as the protocols (rules) followed in a security application (examples include: SSL, IPSec, Kerberos, etc.)</description></item><item><title>Security Services</title><link>https://mohkale.gitlab.io/brain/20210430005448-security_services/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430005448-security_services/</guid><description>Refers to the various services implemented in a secure computer system.
Term Description Confidentiality Maintaining the privacy of data Integrity Ensure data hasn't been tampered with (checksums) authentication Establishing proof of identity Non-repudiation Ability to prove that the sender actually sent the data (signing) Access control Access to information resources are regulated Availability Computer asserts are available to authorised parties when needed See examples [see page 45, examples].</description></item><item><title>Security System</title><link>https://mohkale.gitlab.io/brain/20210430005025-security_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430005025-security_system/</guid><description>A set of goals defined in a system in the presence of an adversary. The adversary will try to violate or bypass our intended goals and a secure system is one which obeys the security policy, regardless of the adversaries actions.
Divided into [see page 44, three] parts:
Part Description Policy Confidentiality, integrity and availability Threat Model Assumptions about adversary, how they might act Mechanism How to achieve the goals (software/hardware) Note: we may also think of threats in terms of [see page 45, security requirements].</description></item><item><title>Segmental Analysis</title><link>https://mohkale.gitlab.io/brain/20201106020932-segmental_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106020932-segmental_analysis/</guid><description>[see page 32, Determine] efficacy of products based on market mapping. I.E.
Look at the future dimensions of the market place. Look at customer segments (targeting the most attractive).</description></item><item><title>Segregated Allocator</title><link>https://mohkale.gitlab.io/brain/20211003185325-segregated_allocator/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211003185325-segregated_allocator/</guid><description>Is an allocator that divides the heap into different areas that are handled by different sub-allocators dependent on the size of the allocation request. Sizes are grouped into powers of two and each size is handled by a different sub-allocator and each size maintains its free list.</description></item><item><title>Self Balancing Trees</title><link>https://mohkale.gitlab.io/brain/20210628054513-self_balancing_trees/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054513-self_balancing_trees/</guid><description>Is a class of trees which automatically re-balance themselves whenever they becomes unbalanced.</description></item><item><title>Semantic Web</title><link>https://mohkale.gitlab.io/brain/20201025195601-semantic_web/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025195601-semantic_web/</guid><description>Web page authors use tags embedded in text to indicate semantic meaning content of the content. Eg. this tag relates to a house.
If all sites are using the same format, search engines can take advantage of this format and give much better search results.</description></item><item><title>Semantics</title><link>https://mohkale.gitlab.io/brain/20210626235445-semantics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626235445-semantics/</guid><description>Associates constructs in the syntax of a language with their meaning. For example in \( 5 + 4 \) the symbols are the syntax, the \( + \) operator has the semantic meaning of addition and the expression evaluates to \( 9 \).</description></item><item><title>Semaphore</title><link>https://mohkale.gitlab.io/brain/20211004050304-semaphore/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211004050304-semaphore/</guid><description>Is a synchronisation primitive much like a Mutex, except instead of being a binary locked or unlocked, it counts down from some upper limit whenever it's acquired and blocks the calling thread when you try to acquire it while the current count is 0.
#include &amp;lt;semaphore.h&amp;gt; sem_t s; sem_init(&amp;amp;s, 0, 10); sem_wait(&amp;amp;s); // Decrement the semaphore. // ... sem_post(&amp;amp;s); // Increment the semaphore. sem_destroy(&amp;amp;s); Code Snippet 1: Outline of the general usage of a semaphore with the semaphore library.</description></item><item><title>Semi-Circle</title><link>https://mohkale.gitlab.io/brain/20210621205315-semi_circle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621205315-semi_circle/</guid><description>A sector that covers half of a circle (\( 180^{\degrees} \)).</description></item><item><title>Semi-supervised Learning</title><link>https://mohkale.gitlab.io/brain/20210208043956-semi_supervised_learning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210208043956-semi_supervised_learning/</guid><description>Is intermittent learning algorithm between unsupervised learning and supervised learning. It's generally an unsupervised learning model however it can use a small number of labelled data to guide the learning process.</description></item><item><title>Sentiment Analysis</title><link>https://mohkale.gitlab.io/brain/20201110203217-sentiment_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110203217-sentiment_analysis/</guid><description>Extract [see page 8, emotions, sentiments or opinions] from texts given by humans.
SA is used to make decisions, answering questions such as:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } - Do people like this movie? - Do people agree with this law? - Did people like me enjoy this movie? - What do people think about [see page 10, [us-airlines](COM3110-w07-sentiment-analysis)]. SA can be seen as equivalent to Opinion Mining, even though a sentiment does not necessarily express an opinion.</description></item><item><title>Sentiment Classification</title><link>https://mohkale.gitlab.io/brain/20201110211048-sentiment_classification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110211048-sentiment_classification/</guid><description>Rule Based Corpus Based</description></item><item><title>Sentiment Summary</title><link>https://mohkale.gitlab.io/brain/20201110211840-sentiment_summary/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110211840-sentiment_summary/</guid><description>Ways to express the results of a sentiment-analysis.
You can summarise the result of sentiment-analysis with the:
bing-liu model using a [see page 38, special] graph [see page 40, absolute-number] of expressed opinions (and proportion of them) [see page 41, evolution] of opinions across time</description></item><item><title>Sequence Diagram</title><link>https://mohkale.gitlab.io/brain/20210701012009-sequence_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701012009-sequence_diagram/</guid><description>Is a UML time-view diagram that illustrates the [see page 15, flow] of messages between object roles (rather than specific instances).
The flow of time in a sequence diagram is downwards, with messages being passed between roles. Rectangles indicate which role has focus and where the box ends there's an explicit return to the previous/calling role. At the start of the diagram there's a focus of control into the first role.</description></item><item><title>Sequence Points</title><link>https://mohkale.gitlab.io/brain/20220201160357-sequence_points/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201160357-sequence_points/</guid><description>TODO</description></item><item><title>Service</title><link>https://mohkale.gitlab.io/brain/20220130203444-service/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220130203444-service/</guid><description>TODO</description></item><item><title>Session Key</title><link>https://mohkale.gitlab.io/brain/20210429001233-session_key/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429001233-session_key/</guid><description>A symmetric key that's [see page 29, generated] and shared between the sender and receiver. It's used for confidentiality and/or integrity.
Session keys are normally generated after authentication is completed and sender/receiver can share it. Any potential attackers can't break the authentication or discover the session key.
Advantages include:
Less common keys are used in communications. Cryptanalysis attacks grow easier the more material encrypted with a specific key is available.</description></item><item><title>Set Complement</title><link>https://mohkale.gitlab.io/brain/20210627001222-set_complement/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627001222-set_complement/</guid><description>The elements of the universe [see page 37, not] in the input set.
\begin{align*} \overline{A} &amp;amp;= \{ x : x \not\in A \} \
x \in \overline{A} &amp;amp;\iff x \not\in A \end{align*}</description></item><item><title>Set Difference</title><link>https://mohkale.gitlab.io/brain/20210627001146-set_difference/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627001146-set_difference/</guid><description>The subset of elements in \( A \) that're [see page 36, not] in \( B \):
\begin{align*} A \setminus B &amp;amp;= \{ x : x \in A \cap x \not \epsilon B \} \
x \in (A \setminus B) &amp;amp;\iff (x \in A) \land (x \not \in B) \end{align*}</description></item><item><title>Set Intersection</title><link>https://mohkale.gitlab.io/brain/20210627001110-set_intersection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627001110-set_intersection/</guid><description>The subset of elements [see page 35, shared] by all the input sets:
\begin{align*} A \cap B &amp;amp;= \{ x : x \in A \land x \in B \} \
x \in (A \cap B) &amp;amp;\iff (x \in A) \land (x \in B) \end{align*}</description></item><item><title>Set Union</title><link>https://mohkale.gitlab.io/brain/20210627001020-set_union/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627001020-set_union/</guid><description>The [see page 34, combination] of all the elements in the input sets:
\begin{align*} A \cup B &amp;amp;= \{ x : x \in A \lor x \in B \} \
x \in (A \cup B) &amp;amp;\iff (x \in A) \lor (x \in B) \end{align*}</description></item><item><title>Sets</title><link>https://mohkale.gitlab.io/brain/20210627000315-sets/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627000315-sets/</guid><description>Is an orderless collection which is defined solely by the [see page 22, objects] it contains, all of which share some property (a logical proposition).
Set theory was initially used to [see page 18, explore] and answer questions about infinities.
There are infinitely many orders of infinities.
Notationally a set is enclosed in curly brackets and has a comma separated list of values. For example: \( \{\text\{false\}, \text\{true\}\} \), \( \{3, 7, 14\} \), or \( \{\text\{red\}, \text\{blue\}, \text\{yellow\}\} \).</description></item><item><title>Shader</title><link>https://mohkale.gitlab.io/brain/20201023013756-shader/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023013756-shader/</guid><description>A shader is a GLSL (C-like) script used to configure part of the graphics pipeline.
Each shader is compiled and linked in the GPU and then for each set of vertices passed into the graphics pipeline, a new shader process is started concurrently and used to determine how to render those vertices.
Structure Here's an example vertex shader:
// specify the OpenGL version (3.3) and run in core-profile #version version_number core // specify any [[id:16ea0666-cb68-41b8-85cb-bd5bc7904484][vertex-attributes]] we&amp;#39;re using.</description></item><item><title>Shader Program</title><link>https://mohkale.gitlab.io/brain/20201023015922-shader_program/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023015922-shader_program/</guid><description>A collection of one or more shaders that must be enabled before it can be used in rendering.
Usage We create a shader program much like a VBO.
unsigned int shaderProgram; shaderProgram = glCreateProgram(); After creation you need to attach one or more shaders to the program.
// both vertexShader and fragmentShader are the ids of shaders // we&amp;#39;ve already defined. glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); Finally we need to link the shaders together in the program.</description></item><item><title>Shadow Volumes</title><link>https://mohkale.gitlab.io/brain/20201027191111-shadow_volumes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027191111-shadow_volumes/</guid><description>An approach to calculating shadows which relies on the [see page 10, volume] of space a projection produces.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Try to represent the invisible volume of space that a shadow creates. The idea being there's a light source on one side of an object and a shadow on the other side.
Take the silhouette of an object to create a cone (volume) Any object within this cone is in a shadowed region.</description></item><item><title>Shadow Zbuffer</title><link>https://mohkale.gitlab.io/brain/20201027195246-shadow_zbuffer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027195246-shadow_zbuffer/</guid><description>A shadow algorithm based on the zbuffer.
Works in two stages using the same approach as zbuffer (without shading):
Render scene from lights POV (without lighting calculations). Render scene from eyes POV (with lighting calculations). We define a shadow-map/depth-map as the depth of each pixel in the zbuffer produced by rendering from the lights POV. After the 1st stage we start rendering from the eyes POV and use the [see page 23, shadow-map] to determine the position and size of shadows.</description></item><item><title>Shadows</title><link>https://mohkale.gitlab.io/brain/20201027185124-shadows/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027185124-shadows/</guid><description>Increase the realism of 3D shaded objects by given depth cues.
The size of a shadow depends on the position of the light.
Early [see page 8, approaches] include shadow volumes or shadow z-buffers which work in two stages:
view-independent - generate shadow info view-dependent - render shadows Some [see page 9, definitions]:
Term Meaning Light Source A point which produces light.</description></item><item><title>Shell</title><link>https://mohkale.gitlab.io/brain/20210717030409-shell/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717030409-shell/</guid><description>Is a computer program that allows you to run programs.
The shell is called the shell because it wraps around and hides the operating system kernel, communicating between each other using a small subset of system calls.</description></item><item><title>Short Term Scheduling</title><link>https://mohkale.gitlab.io/brain/20211009132726-short_term_scheduling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009132726-short_term_scheduling/</guid><description>Is a sort of scheduling which mainly deals with CPU scheduling. That is the processes are already in memory and we just need to swap them into and out of the CPU context.</description></item><item><title>Short Time Energy</title><link>https://mohkale.gitlab.io/brain/20201109220154-short_time_energy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109220154-short_time_energy/</guid><description>Equals the [see page 5, sum] of the squares of the samples in one frames.
\[ E = \sum{L_{Bl}-1}{s2 [iT]} \] Where:
\( E \) Short-time energy. \( L_m \) Length of block \( m \). \( s[iT] \) Sample no \(i\) of signal \(s\). Note: This value is large for voiced speech segments.</description></item><item><title>Shortest-Job-First Scheduler</title><link>https://mohkale.gitlab.io/brain/20211009140433-shortest_job_first_scheduler/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009140433-shortest_job_first_scheduler/</guid><description>Is a scheduling algorithm that schedules the jobs with the shortest total CPU time first.
Note: A realistic implementation of this would use the burst-time (number of CPU cycles) needed to finish the program instead. In many cases it may estimate this using an exponentially decaying weighted rolling average based on the previous burst time.
This scheduler leads to an on average decrease in wait and response times, however to be truly effective the scheduler needs to be omniscient and to estimate the burst-iness of a process.</description></item><item><title>Shoulder Surfing</title><link>https://mohkale.gitlab.io/brain/20210212002442-shoulder_surfing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210212002442-shoulder_surfing/</guid><description>A type of attack which involves directly observing the authentication process either in person or remotely (eg. Entering a password over someones shoulder).</description></item><item><title>Sieve of Eratosthenes</title><link>https://mohkale.gitlab.io/brain/20210830222205-sieve_of_eratosthenes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210830222205-sieve_of_eratosthenes/</guid><description>Is an algorithm for quickly finding all the prime-numbers up-to any given limit.
The sieve works by filling a pad of all the numbers up-to the limit \( n \). We then scratch off the first number as prime and then mark-off all of its multiples as non-prime (because their factors of the last marked prime number). Then we scratch off the next non-marked number as prime and repeat the process.</description></item><item><title>Signal</title><link>https://mohkale.gitlab.io/brain/20201026234940-signal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026234940-signal/</guid><description>A signal is a physical quantity that can carry information. Signals can be described as:
Property Explanation [see page 7, Continuous] Energy is supplied indefinitely and resonance can be sustained (eg. flute). Deterministic Knowing how it's described, you can always reproduce the signal. Deterministic Aperiodic The signal doesn't repeat in a consistent way. Deterministic [see page 8, Periodic] The signal repeats at a fixed period.</description></item><item><title>Signal</title><link>https://mohkale.gitlab.io/brain/20210717022152-computer_signal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717022152-computer_signal/</guid><description>Is a software level interrupt, providing a rudimentary level of inter-process communication and allowing the kernel to signal events to a process.
When a process receives a signal it stops the execution of the current program and makes it respond to the signal. You can define custom signal handlers for some signals using the signal system call.
Signals may be initialised by the OS kernel (example: SIGFPE, SIGSEGV, SIGIO) or by a process such as kill.</description></item><item><title>Signal Correlation</title><link>https://mohkale.gitlab.io/brain/20201109232644-signal_correlation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109232644-signal_correlation/</guid><description>We define [see page 17, correlation], q, of two discrete time signals s and t over an interval N as the sum of the products of the signals at each point, i, in the range N.
\[ q = \sum^{N-1}{s_i \times t_i} \]</description></item><item><title>Signal Processing</title><link>https://mohkale.gitlab.io/brain/20201026233848-signal_processing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201026233848-signal_processing/</guid><description>The analysis, interpretation and manipulation of signals (sensor data).
Possible applications include:
Find patterns Deduce causes of trends Predict (extrapolate) outcomes Transform data (scale, rotate, map) Signal processing often converts time-domain inputs into Frequency Domain to make processing easier.
After analogue-to-digital conversions, speech signals become a sequence of quantised samples. Signal processing is typically performed on a fixed length sequence of these samples called blocks/frames.</description></item><item><title>Simultaneous Equations</title><link>https://mohkale.gitlab.io/brain/20210621192650-simultaneous_equations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621192650-simultaneous_equations/</guid><description>Refers to an equation based on multiple terms expressed across several constraints (equations). To solve a simultaneous equation you must find the values of the given variables that satisfy all the equations.
Solving a Simultaneous Equation The classic way to solve a simultaneous equation is to re-arrange one of the constraints into a form equivalent to one of the terms, and then substitute it into the other equation. We repeat this until we get an equation with only a single term which we can solve.</description></item><item><title>Sine Correlation</title><link>https://mohkale.gitlab.io/brain/20201110171935-sine_correlation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110171935-sine_correlation/</guid><description>Refers to cosine-correlation except instead of using a cosine wave, we use a sine wave.
Just like cosine correlation we find that the correlation of a sine and cosine wave can be written as [see page 4, proportional] to the sine of the phase-difference
\[ q = \alpha \sin(\phi) \]
Note: [see page 3, how] the correlation of a sinus and cosinus varies as a sinus.</description></item><item><title>Single Layer Feed-Forward Neural Network</title><link>https://mohkale.gitlab.io/brain/20210206064559-single_layer_feed_forward_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206064559-single_layer_feed_forward_network/</guid><description>A [see page 4, form] of neural network where [see page 4, each] neuron in the input layer projects to all the neurons in the output layer. There's no back propagation.
Training Training a neural network involves tuning the weights of the algorithm through [see page 12, least mean square] gradient descent.
We [see page 8, define] the error function (AKA cost function) \( E = F(\text{input}, \text{output}; w) \) as a function which quantifies how the error will change given a change in weights ( \( \frac{\delta{E}}{\delta{{w}_{ij}}} \)).</description></item><item><title>Single-factor Authentication</title><link>https://mohkale.gitlab.io/brain/20210211183337-single_factor_authentication/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211183337-single_factor_authentication/</guid><description>A form of authentication which uses only one authentication method at a time.</description></item><item><title>Singular Matrix</title><link>https://mohkale.gitlab.io/brain/20210621223515-singular_matrix/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621223515-singular_matrix/</guid><description>A singular matrix is one with a Determinant equal to 0 (\( \det(A) = 0 \)). These matrices have no inverse. A matrix with a non-zero determinant does have an inverse.
Note: singular-matrices are the only ones that can collapse a shape to a straight line.</description></item><item><title>Skip Gram</title><link>https://mohkale.gitlab.io/brain/20201025210107-skip_gram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025210107-skip_gram/</guid><description>An approach in CWR.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Train shallow feed forward neural net to predict words before and after target word \\(w\\). Basically train the NN to detect the context of words surrounding a target word.</description></item><item><title>Skybox</title><link>https://mohkale.gitlab.io/brain/20201109200830-skybox/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109200830-skybox/</guid><description>Refers to a design process where we have a [see page 18, large cube] with a fixed texture per-face to represent our scene. We place a synthetic object within this scene and use the outer worlds texture to calculate the reflections for environment-mapping.
The general idea is rather than calculating a texture to put around the object, construct a scene with a texture you already have and use that for object reflections.</description></item><item><title>Slack Space</title><link>https://mohkale.gitlab.io/brain/20210318005822-slack_space/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210318005822-slack_space/</guid><description>Refers to the left-over [see page 8, space] from a file when written to a cluster in a disk.
Slack space generally contains information from previously written files.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } For example a 10MB file will probably be split into chunks of 10KB and stored in a continuous section of disk-space. The gaps between where one file ends and another begins is the [see page 8, [slack space](com3501-w05-windows-forensics)].</description></item><item><title>SLD</title><link>https://mohkale.gitlab.io/brain/20210719194532-sld/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719194532-sld/</guid><description>Are domain-names below a top level domain name.</description></item><item><title>Smoothing Kernel</title><link>https://mohkale.gitlab.io/brain/20201109162625-smoothing_kernel/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109162625-smoothing_kernel/</guid><description>The kernel for smoothing, defines the shape of the function that is used to take the average of the neighbouring points. Kernels are often synonymous with convolutional-filters.
Gaussian Kernel A [see page 15, kernel] with the shape of the Gaussian distribution.
For example:
1 1 2 1 ---- 2 4 2 16 1 2 1 Remember a filter must sum to 1, that's why we divide by 16.</description></item><item><title>SMTP Protocol</title><link>https://mohkale.gitlab.io/brain/20211010030428-smtp_protocol/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010030428-smtp_protocol/</guid><description>An application layer protocol allowing one to send plain text emails to an email server.</description></item><item><title>Social Constraints</title><link>https://mohkale.gitlab.io/brain/20210906005820-social_constraints/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906005820-social_constraints/</guid><description>Constraints relating to who, what, and how something will be affected by the system.
Authority: Who will be empowered or disenfranchised? Tensions: Whose job will be made easier or harder?</description></item><item><title>Social Engineering</title><link>https://mohkale.gitlab.io/brain/20210630234834-social_engineering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630234834-social_engineering/</guid><description>Is a attack which psychologically manipulates people into performing actions or divulging confidential information.</description></item><item><title>Socket</title><link>https://mohkale.gitlab.io/brain/20211009181855-socket/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009181855-socket/</guid><description>Is a persistent connection between 2 hosts (possibly the same host) through which data can be passed over a network. It is the network analogy to a file-descriptor or pipes. See socket.
The protocol for networking with UNIX uses the sys/socket.h libraries. This library has bindings for several well known protocols including IPv4 and IPv6 alongside UDP and more. Sockets are declared with both a socket address and a port.</description></item><item><title>Soft Link</title><link>https://mohkale.gitlab.io/brain/20211010190911-soft_link/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010190911-soft_link/</guid><description>Is a file that points to another file on the file-system. Symlinks are created with a special bit so when the OS attempts to interact with the symlink, most of those operations are done on the file pointed to by the symlink.
You can create a symlink using the symlink system-call. Some advantages of symlinks over hardlinks is that they can:
Refer to files that don't exist yet. Point to directories as well as regular files.</description></item><item><title>Soft Tokens</title><link>https://mohkale.gitlab.io/brain/20210211182322-soft_tokens/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211182322-soft_tokens/</guid><description>Apps on your mobile that can generate one-time use passwords for identifications. This is the same mechanism used by uphold.</description></item><item><title>Soft-Max Reward Policy</title><link>https://mohkale.gitlab.io/brain/20210415002352-soft_max_reward_policy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415002352-soft_max_reward_policy/</guid><description>Is a policy which associates each action to a probability based on the natural exponent of its Q-value. \[ P(a) = \frac{e^{Q(s, a) / \tau}}{\sum_{b} e^{Q(s, b) / \tau}} \] Where \( \tau \) is a psuedo-temperature which balances out large \(Q\) values.
The denominator here is the normalising term (dividing by the sum of the numerator for each action) to scale the growth of the policy.</description></item><item><title>Software Architect</title><link>https://mohkale.gitlab.io/brain/20210905234951-software_architect/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210905234951-software_architect/</guid><description>An experienced software engineer who has [see page 4, authority] over high level design decisions in the SDLC.
The architect acts as the bridge between the stakeholders and the team:
Identifying the concerns of different stakeholders. Prioritising their concerns in order of importance. Determines their logical influence on the system. Investigates the physical context of the system. Determines the external constraints on its structure. From all this they decide the high-level architectural design.</description></item><item><title>Software Architecture</title><link>https://mohkale.gitlab.io/brain/20210906010839-software_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906010839-software_architecture/</guid><description>Refers to the high-level design of a system and determined by:
External constraints. User concerns: data security, multi-user access. Logical design: Software packages, subsystems.</description></item><item><title>Software Development Life Cycle</title><link>https://mohkale.gitlab.io/brain/20210430000232-software_development_life_cycle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430000232-software_development_life_cycle/</guid><description>Refers to the process of developing a software system.
Life-cycle activities [see page 9, include]:
Feasibility Study Requirements Elicitation Systems Analysis Formal Specification Implementation Testing Deployment Maintenance</description></item><item><title>Software Engineering</title><link>https://mohkale.gitlab.io/brain/20210626201056-software_engineering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626201056-software_engineering/</guid><description>[see page 14, Software engineering] is the establishment and use of sound engineering principles in order to obtain economically sound software that is reliable and works efficiently on real machines.
The [see page 25, tasks] of software engineering are:
Getting requirements. What does the customer want? High level design. What type of system are we going to build. Low level design. How is the system going to be built? Development.</description></item><item><title>Software Metrics And Estimations</title><link>https://mohkale.gitlab.io/brain/20210626234342-software_metrics_and_estimations/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234342-software_metrics_and_estimations/</guid><description>Aims to [see page 3, measure] the progress or quality of a software project. Why? You can't control what you can't measure.
We [see page 7, define]:
Measure: A directly measurable quantitative indication of a product or process attribute. Metric: A quantitative measure of the degree to which a product or process possesses a given attribute. This isn't directly measurable but calculated using different measures. In general use measures to obtain metrics.</description></item><item><title>Software Safety</title><link>https://mohkale.gitlab.io/brain/20210607024502-software_safety/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607024502-software_safety/</guid><description>[see page 26, Protecting] a system from accidental failures.</description></item><item><title>Software Security</title><link>https://mohkale.gitlab.io/brain/20210607024640-software_security/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607024640-software_security/</guid><description>Protecting a system from active attackers who try to exploit threats.
Usually what is good for safety is also good for security, so the distinction is not so relevant.</description></item><item><title>Software Security Testing</title><link>https://mohkale.gitlab.io/brain/20210607024020-software_security_testing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607024020-software_security_testing/</guid><description>Testing software systems to ensure they meet the security obligations of the system.
Most defensive security mechanism are reactive. They respond to known threats but don't seek out and try to discover possible threats. We [see page 7, need] to be proactive.
The Dilemma We can only ever [see page 4, have] 2 of:
Usability - The system does what's expected of it. Security - The system is secure to use.</description></item><item><title>Software System</title><link>https://mohkale.gitlab.io/brain/20210701011139-software_system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701011139-software_system/</guid><description>Is a program or series of programs running on computer and communicating with each other to accomplish some goal.</description></item><item><title>Software Testing</title><link>https://mohkale.gitlab.io/brain/20210626232428-software_testing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626232428-software_testing/</guid><description>Is the idea of testing the functionality or features of a software system to ensure it works as expected.</description></item><item><title>SohCahToa</title><link>https://mohkale.gitlab.io/brain/20210621214519-sohcahtoa/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621214519-sohcahtoa/</guid><description>Is a relation between the lengths of a right angled triangle, its angle and the trigonometric functions.
\begin{figure}[ht] \centering \incfig{20210610022247} \caption{Annotated figure of a triangle with description of SOHCAHTOA}. \label{fig:sohcahtoa} \end{figure} In fig:sohcahtoa you can see where the fields used by SohCahToa come from. The hypotenuse is the longest side of the triangle and is opposite the right angle, the opposite side is opposite from the angle we know (or are using for sohcahtoa) and the final side is the adjacent.</description></item><item><title>Solid State Drive</title><link>https://mohkale.gitlab.io/brain/20211010162241-solid_state_drive/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010162241-solid_state_drive/</guid><description>Is a disk that can be used for storage. The structure of a SDD is a series of NAND gates on a chips that are flipped to store a 0 or 1.
As of 20121 SSDs are an order of magnitude faster than the same sized hard disk drives and are also less prone to breaking since they have less moving parts.</description></item><item><title>Solid Texture Mapping</title><link>https://mohkale.gitlab.io/brain/20201120185941-solid_texture_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201120185941-solid_texture_mapping/</guid><description>A form of 3d-texture-mapping which [see page 4, applies] a function to each 3D coordinate on the surface of the object (in the world-coordinates).
This [see page 7, differs] from 2D texture mapping by defining the pattern of color variation mathematically, rather than substituting it from an existing texture.
A good function can produce endless patterns.
See an [see page 8, example] of defining a function for a wooden pattern. Note the transformations we apply as we move through the centre axis (u) all [see page 11, contribute] to the final pattern.</description></item><item><title>Solvency Analysis</title><link>https://mohkale.gitlab.io/brain/20201021182900-solvency_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021182900-solvency_analysis/</guid><description>The [see page 7, ability] of a company to survive in the medium/long term. It is often judged in terms of medium-term capital structure of the business.</description></item><item><title>Sorting Algorithm</title><link>https://mohkale.gitlab.io/brain/20210622171157-sorting_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622171157-sorting_algorithm/</guid><description>Is an algorithm to efficiently take a sequence of possibly unsorted elements \( x \) and sort them such that \[ \forall i, j \in \mathbb{N} \; i &amp;lt; j \implies x[i] \leq x[j] \]</description></item><item><title>Sound</title><link>https://mohkale.gitlab.io/brain/20200929233032-sound/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200929233032-sound/</guid><description>Acoustic energy travelling as a mechanical wave through a medium (often air). Sound travels through air and depends on air pressure (density of air molecules). The speed at which sound waves propagate depends on the density of the medium in which it's travelling. See specific values [see page 3, here].
Sound waves are measured in pascals or relative to another wave using Decibels.
Like all waves sound waves have Frequency and Wavelength.</description></item><item><title>Sound Pressure Level</title><link>https://mohkale.gitlab.io/brain/20210128045157-sound_pressure_level/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128045157-sound_pressure_level/</guid><description>A measure of the local change in atmospheric pressure (from the global ambient pressure) caused by a sound wave. Measured in decibels instead of pascals.</description></item><item><title>Source Filter Model</title><link>https://mohkale.gitlab.io/brain/20201102163834-source_filter_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102163834-source_filter_model/</guid><description>A [see page 17, model] for generating speech using a pulse-generator and a noise-source which is passed through a vocal tract filter.</description></item><item><title>Space Subdivision</title><link>https://mohkale.gitlab.io/brain/20201016222517-space_subdivision/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201016222517-space_subdivision/</guid><description>A 3D representation based on [see page 20, decomposing] the space into a region (grid) and then labelling what's within or outside of the region. This resolution of this approach depends on the resolution of the grid.
This approach in 3D is called voxels (equal subdivision of space into cubes).
A partial optimisation for space subdivision is the [see page 24, quadtree]. For each square in the grid we subdivide it into 4 and recurse into sub squares determining which parts of the parent grid is occupied by the object.</description></item><item><title>Spanning Tree</title><link>https://mohkale.gitlab.io/brain/20210622174610-spanning_tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174610-spanning_tree/</guid><description>A spanning tree of a graph \( G \) is a sub-graph which includes all the vertices of \( G \) and is also a tree.</description></item><item><title>Sparse Graph</title><link>https://mohkale.gitlab.io/brain/20210628020444-sparse_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628020444-sparse_graph/</guid><description>Is a graph where the number of edges is smaller than \( |V|^2 \).</description></item><item><title>Spatial Partitioning</title><link>https://mohkale.gitlab.io/brain/20210106010840-spatial_partitioning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106010840-spatial_partitioning/</guid><description>A ray-tracing intersection [see page 25, optimisation-technique] which divides the world into a grid and associates each object with the cells of the grid the object contains. We then find which cells a ray passes through and then only test objects whose cells overlap with the rays cells.
The efficiency and reliability of this approach depends of the resolution of the grid we create.
Space partitioning isn't limited to regular grids (with [see page 26, voxels]), it can also use:</description></item><item><title>Speaking</title><link>https://mohkale.gitlab.io/brain/20201010154051-speaking/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201010154051-speaking/</guid><description>Speech is the continuous production of sound in a structured form to convey information.
The mamalian vocal system is [see page 2, divided] into several systems:
System Description Lungs Source of energy. Larynx Source of sound. Oral Cavity Changes the shape of the sound. Air Flow Determines how loudly you speak (small sound = small inhale). Pharynx Produces a harmonic-rich buzzind sound (influenced by body size).</description></item><item><title>Special Pricing Decisions</title><link>https://mohkale.gitlab.io/brain/20201114224515-special_pricing_decisions/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114224515-special_pricing_decisions/</guid><description>Decisions relating to pricing decisions outside the main market.
Mainly relates to one time special orders or orders at prices less than market price.
Things to Consider Customer doesn't expect to compete in the same market. Customer doesn't expect to receive this price for future transactions.</description></item><item><title>Specification</title><link>https://mohkale.gitlab.io/brain/20210627020013-specification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627020013-specification/</guid><description>Is the task of [see page 5, modelling] a computer system together with its functionality and behaviour. It can be understood as a formal description of the problems to be solves.</description></item><item><title>Spectra</title><link>https://mohkale.gitlab.io/brain/20210129063505-spectra/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129063505-spectra/</guid><description>A [see page 2, graph] of frequency (\(X\)) against amplitude (\(Y\)).
A spectra is essentially just a slice through a spectrogram at a given point in time (or averaging over a time period). Think of a spectrogram as taking multiple spectra and sticking them together, line by line, to form a new graph.</description></item><item><title>Spectral Analysis</title><link>https://mohkale.gitlab.io/brain/20210128051957-spectral_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128051957-spectral_analysis/</guid><description>The process of splitting up a time-domain signal (eg. recorded speech signal) into a frequency spectrum (showing the various frequencies on the X domain with their power on the Y domain).</description></item><item><title>Spectral Leakage</title><link>https://mohkale.gitlab.io/brain/20201110185341-spectral_leakage/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110185341-spectral_leakage/</guid><description>DFT computes the spectrum at N evenly spaced discrete frequencies and assumes periodicity outside the analysis frame. That is the signal repeats outside of the sampled window.
Spectral leakage refers to [see page 11, discontinuities] which occur due to DFT assuming a signal is periodic. This can happen for:
periodic signals with a non-whole number of cycles in the analysis frame. Signal gets cut off in the middle of a cycle.</description></item><item><title>Spectre</title><link>https://mohkale.gitlab.io/brain/20211010225913-spectre/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010225913-spectre/</guid><description>Is a computer-bug exploiting out-of-order executions. It happens when instructions that otherwise would not be executed are speculatively executed due to our of order instruction execution.
char *a[10]; for (int i = 10; i != 1; --i) { a[i] = calloc(1, 1); } a[0] = 0xCAFE; int val; int j = 10; // This will be in a register int i = 10; // This will be in main memory for (int i = 10; i !</description></item><item><title>Spectrogram</title><link>https://mohkale.gitlab.io/brain/20210129063456-spectrogram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129063456-spectrogram/</guid><description>A [see page 2, graph] of time (X) against frequency (Y) and amplitude (Z).
Note: This is often drawn in 2D with amplitude being shown as color variations over time.
Observe the spectrogram for:
[see page 7, vowels] [see page 11, fricatives] [see page 12, nasals] [see page 13, plosives]</description></item><item><title>Specular Lobe</title><link>https://mohkale.gitlab.io/brain/20201023202846-specular_lobe/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023202846-specular_lobe/</guid><description>The tiny [see page 16, bright spots] you see on shiny illuminated surfaces. See specular illumination.</description></item><item><title>Specular Mapping</title><link>https://mohkale.gitlab.io/brain/20201108005529-specular_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201108005529-specular_mapping/</guid><description>Is the specular equivalent of diffuse-mapping.
This is a simple way to change the reflectivity of parts of an objects surface. Consider a wooden box with a metal rim, the metal is reflective and should have a specular-lobe but the wood isn't and shouldn't.
We can get this affect by specifying the specular intensity through another texture. We multiply the specular value we get by the equivalent value at the same coordinates on this texture.</description></item><item><title>Speech</title><link>https://mohkale.gitlab.io/brain/20201015002314-speech/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201015002314-speech/</guid><description>Speech is the continuous production of sound in a structured form to convey information. By continuous I mean that speech doesn't require a [see page 2, break] between utterances; a speech recording is a continuous signal.
Speech is the most sophisticated behaviour of the most complex organism in the known universe. Richness Speech is [see page 12, rich] in various kinds of information.
Information Meaning Example Linguistic What's being said (distinguishing meaning) Ahead vs.</description></item><item><title>Speech Frames</title><link>https://mohkale.gitlab.io/brain/20201109215002-speech_frames/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109215002-speech_frames/</guid><description>Frames refer to a fixed length sequence of quantised signal samples (after ADC conversion). signal-processing is often done on speech frames.
Due to the fact that the vocal tract changes shape fairly slowly with time and tends to be fairly constant over short intervals, it makes sense to process over short intervals rather than be mislead by subtle frequency shifts over these intervals. .
Frame Size Requirements The choice of frame size is a [see page 1, compromise] of:</description></item><item><title>Speech Processing</title><link>https://mohkale.gitlab.io/brain/20200929184327-speech_processing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200929184327-speech_processing/</guid><description>The study of speech signals. Or more aptly a special application digital Signal Processing for speech signals.
Kinds of speech processing technologies:
Digital Speech Coding - Encode and transmit speech, eg. telephone. Automatic Speech Recognition - Voice to text parsing Text to Speech Synthesis - Text to speech conversion Spoken Language Dialogue System - Automated Conversations (combination of ASR and TSS), eg. telephone marketing. Applications of these technologies include:</description></item><item><title>Speech Segmentation</title><link>https://mohkale.gitlab.io/brain/20201020222042-speech_segmentation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020222042-speech_segmentation/</guid><description>The process of [see page 16, splitting] a speech signal at the boundary between phonetic segments.
We define:
Term Meaning Acoustic Segment The signal range related to a single phonetic term or gap between terms. Acoustic Segment Points The point at the boundary between/separating two acoustic segments. Phonetic Segment The signal range relating to a sound (vowel/consonant). For splosives which often have a:</description></item><item><title>Spiral Model</title><link>https://mohkale.gitlab.io/brain/20210626220826-spiral_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626220826-spiral_model/</guid><description>Is a software design model that [see page 14, combines] various other models, separates them into firstly iterations and then phases.
Figure 1: The spiral design model (wikipedia).</description></item><item><title>Spoofing</title><link>https://mohkale.gitlab.io/brain/20210630232058-spoofing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210630232058-spoofing/</guid><description>Is a security vulnerability where we disguise communication from an unknown source as being from a trusted source.</description></item><item><title>Spotlight</title><link>https://mohkale.gitlab.io/brain/20201108020323-spotlight/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201108020323-spotlight/</guid><description>Is a point-light which limits light to a subset of the radius of the light.
Think of it as a cone exuding light in a certain direction to a certain degree, anything outside of the cone is still dark.
Smoothing To add soft edges to a spotlight, you define two cones (cutoff radiuses). One for the light itself, and other which slowly decreases intensity as you approach the cutoff.
We can define this as \( I = \frac{\theta - \lambda}{\epsilon} \) Where:</description></item><item><title>SQL</title><link>https://mohkale.gitlab.io/brain/20210815204153-sql/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210815204153-sql/</guid><description>Is the standard query language for relational databases.
This differs from the classic relational algebra of a relational database by returning lists instead of sets (meaning the uniqueness of a fetched record isn't guaranteed by the engine). It also moves away from the classic operations described in relational algebra, using SELECT to perform a PROJECT operation and WHERE to perform a SELECT operation.
Syntax The actual syntax of SQL can vary from one dialect to another however the core constructs remain the same in most cases.</description></item><item><title>SQL Injection</title><link>https://mohkale.gitlab.io/brain/20210211053915-sql_injection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211053915-sql_injection/</guid><description>A form of attack which [see page 11, exploits] a failure to properly escape SQL keywords in a user-submitted query. Allows attacker to access more data than initially intended.
SELECT*FROMfooWHEREusername=&amp;#39;QUERY&amp;#39;; Where the query is set to bar' OR 1 == 1 OR ' results in:
SELECT*FROMfooWHEREusername=&amp;#39;bar&amp;#39;OR1=1OR&amp;#39;&amp;#39;; This query will return every row in the table foo, which lets users quickly [see page 15, accumulate] information including perhaps private or sensitive data.</description></item><item><title>SSH</title><link>https://mohkale.gitlab.io/brain/20211010030605-ssh/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010030605-ssh/</guid><description>An application layer protocol for spawning secure remote shells.</description></item><item><title>SSL</title><link>https://mohkale.gitlab.io/brain/20210428235810-ssl/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428235810-ssl/</guid><description>A network protocol which runs above TCP/IP and allows the creation of a secure see page 7, communication channel between a sender and receiver.
A [see page 7, secure protocol] that runes above TCP/IP and allows users to encrypt data and authenticate a servers/vendors identity securely. It allows clients and servers to select cryptographic algorithms or ciphers that they both support using CipherSuites in the handshake.
SSL supports several cryptographic algorithms which must be agreed upon between the client and the recipient at the handshake.</description></item><item><title>Stable Sort</title><link>https://mohkale.gitlab.io/brain/20210628053701-stable_sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628053701-stable_sort/</guid><description>Is a sorting algorithm where numbers with the same values appear in the [see page 17, same order] in the sorted array as they were in the input array.</description></item><item><title>Stack</title><link>https://mohkale.gitlab.io/brain/20210628054006-stack/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054006-stack/</guid><description>Is a data structure where only the top element is accessible. Adding an element pushes it to the top of the stack and removing an element removes it from the top of the stack. Think of a [see page 5, stack] as in a stack of plates with a last in, first out policy.
Table 1: see page 6, [Operations] on stacks. Method Description Push(S, x) Add x to the stack S.</description></item><item><title>Stack Protectors</title><link>https://mohkale.gitlab.io/brain/20211010230639-stack_protectors/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010230639-stack_protectors/</guid><description>Is a compiler-level way to prevent buffer-overflow attacks.
Essentially the compiler will place a value that resides in the stack and must remain constant throughout the function call. If it's overridden at the end of the function, such as by a buffer overflow, the runtime will abort and report to the user that stack smashing was detected.</description></item><item><title>Stack Smashing</title><link>https://mohkale.gitlab.io/brain/20211010224548-stack_smashing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010224548-stack_smashing/</guid><description>Is a security attack where we pass in a very large string and get the program to overflow past the buffer the string is being read into and get the program to do something unintended.
void greeting(const char *name) { char buf[32]; // No check on size of main, it may overflow buf. strcpy(buf, name); printf(&amp;#34;Hello, %s!\n&amp;#34;, buf); } int main(int argc, char *argv[]) { if (argc &amp;lt; 2) { return 0; } greeting(argv[1]); return 0; } Code Snippet 1: Example of a program vulnerable to stack smashing.</description></item><item><title>Standardisation</title><link>https://mohkale.gitlab.io/brain/20210216035719-standardisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216035719-standardisation/</guid><description>A form of data normalisation where we subtract the mean from each point and then divide by the standard-deviation.
This works quite well on noisy-data.</description></item><item><title>Standing Wave</title><link>https://mohkale.gitlab.io/brain/20201115212641-standing_wave/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201115212641-standing_wave/</guid><description>A special case of wave-(/brain/20200930001515-superposition/) where certain points (nodes) along the wave are fixed/standing. See here.
The idea being that a superimposed standing wave has:
points where the amplitude is always cancelled out (and is thus constant) points where the wave is oscillating between maxima and minima, but is never anywhere else along the amplitude. Generally when a wave superimposes onto itself it constructively and destructively interferes at different points across the medium of travel causing a visibly random/noisy (irregular and non-repeating) pattern.</description></item><item><title>Starvation</title><link>https://mohkale.gitlab.io/brain/20211007031028-starvation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211007031028-starvation/</guid><description>Is a problem in multi-threaded systems such as the reader-writer problem where constant requests from many reader threads prevent the writer thread from ever being able to continue. That is the writer blocks all the oncoming readers while it's running, but is itself blocked until all the already running reader threads finish. Thus if we receive constant requests for reads the writer can't ever proceed.</description></item><item><title>stat</title><link>https://mohkale.gitlab.io/brain/20211010191922-stat/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010191922-stat/</guid><description>Is a system-call that allows you retrieve metadata about files stored in the inode. See stat.
Table 1: Variants of stat. Function Description stat Stat a file from a given path fstat Stat a file for which you already have an open file-descriptor lstat Identicle to stat except for symlinks it stats the link (not the linked to file)</description></item><item><title>State Based Design</title><link>https://mohkale.gitlab.io/brain/20210911153835-state_based_design/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911153835-state_based_design/</guid><description>Is a UI design based on state-machines where each state [see page 18, corresponds] to a different user-screen. Transitions corresponds to actions only available on that screen and transitions either return you to the current screen or take you to a different one.</description></item><item><title>State Machine Diagram</title><link>https://mohkale.gitlab.io/brain/20210701011949-state_machine_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701011949-state_machine_diagram/</guid><description>Is a UML time-view diagram, to represent state-based (reactive) systems.
\begin{figure} \centering \begin{tikzpicture} \umlstateinitial[name=Init] \umlbasicstate[y=-2.5]{Idle} \umlbasicstate[x=5, y=-4]{Accepting Coins} \umlbasicstate[y=-6]{Dispensing} \umltrans{Init}{Idle} \umlHVtrans[arg=insert coin, pos=0.5]{Idle}{Accepting Coins} \umltrans[arg=insert coin, recursive=-10|10|3cm, pos=1.5, recursive direction=right to right]{Accepting Coins}{Accepting Coins} \umlVHtrans[arg=insert coin/ready, pos=0.5]{Accepting Coins}{Dispensing} \umlHVtrans[arg=cancel/eject coins, pos=0.5]{Accepting Coins}{Idle} \umltrans[arg=cancel/eject coins, arm1=2cm, pos=0.3]{Dispensing}{Idle} \umltrans[arg=select/dispense drink, pos=0.6]{Dispensing}{Idle} \end{tikzpicture} \label{fig:state-machine} \caption{Example state machine diagram for a vending machine.} \end{figure} The [see page 4, semantics] of a state machine are simple.</description></item><item><title>State Pattern</title><link>https://mohkale.gitlab.io/brain/20210922051833-state_pattern/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922051833-state_pattern/</guid><description>Is a software design pattern where the behaviour of an object adapts to changes in its internal state. For example a TCP connection can exist in different states.
This pattern uses extensible contingent behaviour [see page 24, indicating] generic behaviour.</description></item><item><title>Statement of Cash Flows</title><link>https://mohkale.gitlab.io/brain/20201018231915-statement_of_cash_flows/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018231915-statement_of_cash_flows/</guid><description>.org-center { margin-left: auto; margin-right: auto; text-align: center; } summarises information about the cash inflows (receipts) and outflows (payments) for a specific period of time. It should [see page 52, answer]:
Operating activities: Where did cash come from? Investing activities: What was the cash used for? Financing activities: What was the change in cash balance? Basically summarise [see page 53, the flow of cash].
Note: profit does not equal cash.</description></item><item><title>Statement of Financial Position</title><link>https://mohkale.gitlab.io/brain/20201018231629-statement_of_financial_position/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201018231629-statement_of_financial_position/</guid><description>[see page 27, Reports] the Assets, Liabilities, and Equity of a company at a specific date.
Warn: this statement doesn't show the current market value of the companies assets, it only shows what it's value was at the time of purchase. Such assets need to be depreciated to account for the loss of value over time.
This statement also excludes assets which don't have a tangible value (eg. Goodwill or business reputation).</description></item><item><title>Static Code Analysis</title><link>https://mohkale.gitlab.io/brain/20210607025019-static_code_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607025019-static_code_analysis/</guid><description>An approach to test computer software security through [see page 11, automated] processes.
Generally SCA refers to automated analysis that's done at compile time, but can also take into account semantics (data-flow and control flow analysis, abstract interpretation, symbolic evaluation, constraint solving, program evaluation and model-checking). [see page 19, Examples] of which include general linting (eg: unused variables), unreachable code detection, missing variable initialisation, etc. See [see page 20, example] static analysis tools.</description></item><item><title>Static Modelling</title><link>https://mohkale.gitlab.io/brain/20201029171344-static_modelling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201029171344-static_modelling/</guid><description>An approach to building models for text compression where you already have a model before you start compressing. For example having the top 1000 most common words alongside short keys for them.
Note: canonical Huffman codes are good for static/semi-static models.
Semi-Static-Modelling Is an alternative to static modelling where you use 2 passes. One to build a model and then another to apply it whilst compressing text.</description></item><item><title>Stationary Assumption</title><link>https://mohkale.gitlab.io/brain/20210107232044-stationary_assumption/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210107232044-stationary_assumption/</guid><description>The assumption that over short intervals, speech is stationary.</description></item><item><title>Stationary Point</title><link>https://mohkale.gitlab.io/brain/20210621235415-stationary_point/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621235415-stationary_point/</guid><description>A point on a curve where the gradient of the curve is 0. These points manifest themselves on curves that demonstrate both increasing and decreasing behaviour. When the curve reaches a local minimum or maximum its gradient drops to 0 as it flips to an increasing gradient (from a decreasing one) or vice versa.
\begin{figure} \centering \begin{tikzpicture} \begin{axis}[axis lines=center, xmin=-5, xmax=5, ymin=-5, ymax=5, domain=-5:5, grid=both] \addplot[color=green]{x^3 + 3*x^2};, \addplot[only marks] coordinates {(-2, 4) (0, 0)};, \end{axis} \end{tikzpicture} \qquad \caption{A graph with 2 stationary points.</description></item><item><title>Stationary Signals</title><link>https://mohkale.gitlab.io/brain/20201027003544-stationary_signals/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027003544-stationary_signals/</guid><description>Does the signals properties [see page 22, change] over time. Properties under consideration include:
Amplitude Frequency Noise of constant mean and variance Speech Speech is a mixture of periodic, aperiodic and stochastic signals, making it non-stationary. However we [see page 24, generally] treat speech as quasi-stationary (AKA white-space stationary). Meaning it's stationary over a short time interval. This interval is generally clamped to between 10-30 msec.
I.E. Over a short period, the structure of a speech signal can be analysed.</description></item><item><title>Statutory Defences</title><link>https://mohkale.gitlab.io/brain/20201023234937-statutory_defences/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023234937-statutory_defences/</guid><description>[see page 12, Applications] of copyrighted work which isn't treated as a breach.</description></item><item><title>Steganography</title><link>https://mohkale.gitlab.io/brain/20210214235706-steganography/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210214235706-steganography/</guid><description>Is a form of encryption that tries to hiding secrets in plain sight. For example using spare bits in an image (for colors that aren't actually shown) to contain information we want to hide.
It's the [see page 3, science] of hiding messages inside of other messages.</description></item><item><title>Sticky Note</title><link>https://mohkale.gitlab.io/brain/20210911015856-sticky_note/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911015856-sticky_note/</guid><description>A UML construct used to attach further detail to an existing construct like a class, field or association. This looks exactly like a sticky note.
\begin{figure} \centering \begin{tikzpicture} \umlsimpleclass[width=5]{SomeClass}; \umlnote[y=-3.5]{SomeClass}{SomeClass does \ldots} \end{tikzpicture} \caption{An example sticky note} \end{figure}</description></item><item><title>Stochastic Gradient Descent</title><link>https://mohkale.gitlab.io/brain/20210305025647-stochastic_gradient_descent/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210305025647-stochastic_gradient_descent/</guid><description>A variant of gradient descent where the batch size is set to 1.</description></item><item><title>Stochastic Ray Tracing</title><link>https://mohkale.gitlab.io/brain/20210106015345-stochastic_ray_tracing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210106015345-stochastic_ray_tracing/</guid><description>Is a pre-processing [see page 6, step] applied to outgoing rays to fix aliasing issues.
The general problem this addresses is that for [see page 4, example] if we use rendered pixels to detect ray collisions, if the resolution of the screen is too small, the intersection may fail even though the ray does go through the object in world coordinates. We can still get around this issue with super-sampling, however that's effectively raising the resolution (reducing the aliasing), not fixing the aliasing.</description></item><item><title>Stochastic Sampling</title><link>https://mohkale.gitlab.io/brain/20201109191821-stochastic_sampling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109191821-stochastic_sampling/</guid><description>A post-filtering approach for fixing aliasing issues which uses ray-tracing to sample pixels randomly (jittering).
The approach is to use sub-samples, each [see page 23, randomly] distributed across a pixel, to determine what color it should be. In areas with a lot of texture changes, this produces a noisy affect (contrasting with the blurring found in other post-filtering approaches).
Method:
Send out some samples for each pixel. If all of them are the same, use that color.</description></item><item><title>Stoplist</title><link>https://mohkale.gitlab.io/brain/20201103212441-stoplist/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201103212441-stoplist/</guid><description>A form of term-manipulation. A stop list is a list of words which don't give a good indication about the contents of the document (eg. the). These are often the most frequent words in the document. We then don't maintain an index for these words because they aren't useful.
Here's a list of common stoplist words:
a, about, above, across, always, am, among, amongs, both, being, co, could. Too Strong A common issue with the usage of a stop list is that how do we then search for phrases like &amp;quot;to be or not to be&amp;quot;?</description></item><item><title>Story Cards</title><link>https://mohkale.gitlab.io/brain/20210626230330-story_cards/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626230330-story_cards/</guid><description>A short [see page 39, story] of what a stakeholder will do with a system written from the point of view of the person using the application.
Story cards generally have a priority, value/reward, and cost (time to develop). If a story card takes [see page 23, too long], such as 3-weeks, the client is asked to split the story card into smaller stories.
The [see page 43, 3Cs] of user stories are:</description></item><item><title>Straight Line</title><link>https://mohkale.gitlab.io/brain/20210621191231-straight_line/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621191231-straight_line/</guid><description>A straight line is an equation of the form \( y = mx + c \), where \( m \) is the gradient of the line and \( c \) is the point where the line meets the x-axis (when \( x = 0 \)).
We can define the gradient from any 2 points on the line by using the formula \[ m = \frac{y_2 - y_1}{x_2 - x_1} \]</description></item><item><title>Stream Cipher</title><link>https://mohkale.gitlab.io/brain/20210215024953-stream_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215024953-stream_cipher/</guid><description>A cipher which combines (XORs) a psuedo-random digit stream with the plaintext digit stream to get the ciphertext. In this implementation the algorithm encrypts the plain-text one bit at a time.
Classical Stream Cipher Model A Stream Cipher that takes the output of an LFSR (or series of combined LFSR) and XORs it with the plain-text stream to get the ciphertext.</description></item><item><title>Stream Generator</title><link>https://mohkale.gitlab.io/brain/20210215041539-stream_generator/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215041539-stream_generator/</guid><description>Is an algorithm to generate a sequence of bits (often randomly).
A stream-generator can be keyed meaning we can deterministically control the series of bits in the stream by assigning some key/seed to the stream at the start.
A stream generator can be seen as [see page 27, balanced] if it outputs 0 or 1 an equal number of times based on the permutation of possible inputs to the generator (if it takes any).</description></item><item><title>STRIDE</title><link>https://mohkale.gitlab.io/brain/20210430010028-stride/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430010028-stride/</guid><description>A [see page 62, standard] for identifying threats which is an anagram for:
Term Description Spoofing Can an attacker gain access using a false identity? Tampering Can an attacker modify data as it flows through the app? Repudiation If an attacker denies doing something, can we prove he did it? Information disclosure Can an attacker gain access to private or potentially injurious data?</description></item><item><title>Strong AI</title><link>https://mohkale.gitlab.io/brain/20210926204625-strong_ai/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926204625-strong_ai/</guid><description>The strong approach to AI is the modern approach to artificial intelligence, incorporating domain specific knowledge to allow larger reasoning steps and more easily handle frequent cases in narrow areas of expertise.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } One might say to solve a hard problem, you have to almost know the answer already.</description></item><item><title>Sub-Graph</title><link>https://mohkale.gitlab.io/brain/20210622173918-sub_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622173918-sub_graph/</guid><description>A sub-graph of a graph \( G \) is a graph, each of whose vertices belongs to \( G \) and whose edges belongs to \( G \).</description></item><item><title>Subject</title><link>https://mohkale.gitlab.io/brain/20210211061007-subject/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211061007-subject/</guid><description>Something that can act on an Object. Eg. A human person.
Note: A subject [see page 18, can] be an object. eg. John the user (a subject) could create a process (object) by logging on which can operate act (as a subject) on files (objects).</description></item><item><title>Subjectivity Analysis</title><link>https://mohkale.gitlab.io/brain/20201110204955-subjectivity_analysis/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110204955-subjectivity_analysis/</guid><description>Decide whether some text is factual or subjective. This is often the first step in sentiment-analysis.</description></item><item><title>Subjectivity Classification</title><link>https://mohkale.gitlab.io/brain/20201110210815-subjectivity_classification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110210815-subjectivity_classification/</guid><description>Assert whether a given sentence is objective (factual) or subjective (opinion-driven).
Sentence Similarity Compare input with sentences which are known to be subjective. See how similar they are.
Naive Bayes Assert sentence is subjective depending on its word content. This is a probabilistic approach.</description></item><item><title>Subsets</title><link>https://mohkale.gitlab.io/brain/20210627000510-subsets/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627000510-subsets/</guid><description>If every element of a set \( A \) is an element of another set \( B \) then \( A \) is a subset of \( B \) (written as \( A \subseteq B \)) and \( B \) is a subset of \( A \) (written as \( B \subseteq of A \)) and hence \( A = B \).
The [see page 32, laws] for subsets are:</description></item><item><title>Substitution Cipher</title><link>https://mohkale.gitlab.io/brain/20210215021214-substitution_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215021214-substitution_cipher/</guid><description>A [see page 9, form] of cipher that encrypts a message \( \subset \textit{M} \) by applying the substitution process (mapping one character to another) to each character \( \subset A \) in the alphabet.
The encryption function for a substitution cipher is bijective, meaning the decryption process is simply encryption applied in reverse.
The general issue with substitution-cipher based encryptions is that:
Structure (of any type) in the plaintext reveals itself in the ciphertext</description></item><item><title>Substitution Permuation Cipher</title><link>https://mohkale.gitlab.io/brain/20210605030836-substitution_permuation_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210605030836-substitution_permuation_cipher/</guid><description>Is a Composite Cipher that combines both a permutation and substitution to produce more secure ciphers. Many modern ciphers are implemented using multiple layers of this same system.
The need for substitution-permutation cipher ciphers arises from the fact that:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } Ciphers based on either substitution or transposition are insecure. The general advantage of composite ciphers is that:
Term Gives us Description Substitution Confusion Replaces some bits with other bits Permutation Diffusion Spreads bits around to make it harder to follow them</description></item><item><title>Substitution Permuation Network</title><link>https://mohkale.gitlab.io/brain/20210216023404-substitution_permuation_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210216023404-substitution_permuation_network/</guid><description>A [see page 5, encryption-system] performing both substitution and permutation across a [see page 29, series] of rounds.
The order is permutation then substitution, with the output of the S-box of one round being the input to the permutation of the next round.</description></item><item><title>Summation</title><link>https://mohkale.gitlab.io/brain/20210621231237-summation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621231237-summation/</guid><description>Refers to adding up a collection of elements.
Commonly we use the \( \Sigma \) symbol to mean the sum of. The value at the head of it specifies how long this summation will last (for example 20 iterations), the bottom value assigns a variable to reference the current value of the iteration and perhaps initialise the first value (for example \( n = 5 \)), and the body of the sigma is a function that's repeated for each iteration and later summed together.</description></item><item><title>Sunk Cost</title><link>https://mohkale.gitlab.io/brain/20201114220954-sunk_cost/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114220954-sunk_cost/</guid><description>A [see page 3, cost] that has been incurred by a decision that has been made in the past and cannot be changed by any decision in the future.
For example a company has a machine which they paid £2000.00 for. In deciding to sell it they consider this £2000.00 to be sunk. They've already paid it and there's no way to get it back.</description></item><item><title>Super Sampling</title><link>https://mohkale.gitlab.io/brain/20201109191447-super_sampling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109191447-super_sampling/</guid><description>A form of uniform post-filtering used to fix aliasing issues.
Render a virtual image at n times resolution and then filter from this larger image.
For SSAA we render onto a larger buffer and then for each pixel in screen space, we find the corresponding [see page 19, region] in the buffer and use a convolutional filter to determine the color for the given pixel.
Adaptive Super Sampling [see page 24, Uses] more sub-pixel samples around the edges of an object.</description></item><item><title>Superblock</title><link>https://mohkale.gitlab.io/brain/20211010180825-superblock/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010180825-superblock/</guid><description>Is a disk-block that contains metadata about inodes and other disk blocks.
Example of data stored on the superblock includes a journal, inodes, the location of the first inode on the disk. An important thing to note about the superblock is that it's always at a known location on disk and has a fixed size. If the OS can't find the superblock your computer may fail to boot.
Note: Modern file-systems may actually contain multiple super-blocks and a super-super-block that keep tracks of which sectors are governed by which super-blocks (helping to avoid fragmentation.</description></item><item><title>Superposition</title><link>https://mohkale.gitlab.io/brain/20200930001515-superposition/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200930001515-superposition/</guid><description>The [see page 13, affect] when two waves interfere with each each other.
Interference can be either:
Type Description Constructive Amplify each other, when they have the same phase Destructive Cancel each other out, when they have inverse phase When waves encounter an obstacle they're reflected. When they reflect back onto themselves they can constructively (or destructively) interfere with themselves through superposition.</description></item><item><title>Supervised Classifier</title><link>https://mohkale.gitlab.io/brain/20201125172855-supervised_classifier/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201125172855-supervised_classifier/</guid><description>Is a classifier that is trained through supervised learning. Eg. bayes-classifier
We generally supply the classifier with [see page 10, 3 sets] of data:
Training -&amp;gt; estimate probability distribution of discrete classifications. Development -&amp;gt; Used to fine tune classifier parameters to select best model. Test -&amp;gt; Evalaute the classifier (make sure it doesn't reproduce training result) Training data should be:
Aspect Meaning [see page 28, representative] Even if the result is wrong, it should be derivable from the training data.</description></item><item><title>Supervised Learning</title><link>https://mohkale.gitlab.io/brain/20210206035256-supervised_learning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206035256-supervised_learning/</guid><description>A classifier training [see page 7, process] that learns, using labelled sample data, how to classify unlabelled data.
Samples are supplied as: \[ \{({x}^{1}, {t}^{1}), ({x}^{2}, {t}^{2}), \ldots, ({x}^{p}, {t}^{p}) \} \] With:
\( {x}^{i} \) being the sample \( i \) \( {t}^{i} \) being the label of a sample \( i \). The main [see page 8, goal] in supervised learning is using the known classes of samples to tune the classifier (learn the weights) that minimise the error/cost function.</description></item><item><title>Surds</title><link>https://mohkale.gitlab.io/brain/20210621191938-surds/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621191938-surds/</guid><description>Refers to numbers containing square root symbols, such as \( \sqrt{12}, \sqrt{3}\sqrt{5}, 5 + \sqrt{78} \) etc.
Surds can be simplified, split up and otherwise operated on like regular numbers. For example \( \sqrt{5} = \sqrt{5} \sqrt{1} \), or more practically:
\begin{align*} \sqrt{48} &amp;amp;= \sqrt{48} \\
&amp;amp;= \sqrt{16} \sqrt{3} \\\\ &amp;amp;= 4 \sqrt{3} \end{align*}
In many cases you may end up with a fraction that contains a surd on its denominator, in this situation we'd often like to rationalise it to a regular number.</description></item><item><title>Surjection</title><link>https://mohkale.gitlab.io/brain/20210626024945-surjection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626024945-surjection/</guid><description>A function whose co-domain is [see page 7, equivalent] to its range. That is for every output the function has at least one input that maps to it.</description></item><item><title>Swap</title><link>https://mohkale.gitlab.io/brain/20210622171841-swap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622171841-swap/</guid><description>A simple algorithm to swap two elements in an array.
def swap(arr, k, l): tmp = arr[k] arr[k] = arr[l] arr[l] = tmp Code Snippet 1: Swap implementation. A lot of hardware has dedicated commands to do this, but many higher level languages don't expose this abstraction. Instead we commonly save the current value in a temporary variable, update the current value of the first element and then set the second element to the temp value.</description></item><item><title>Switch</title><link>https://mohkale.gitlab.io/brain/20210428234544-switch/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428234544-switch/</guid><description>Is a device operating at layer 2 of the OSI Model. The switch is used to connect multiple devices together in the same network.
Nowadays many switches have been merged into routers.</description></item><item><title>Syllable</title><link>https://mohkale.gitlab.io/brain/20210129041020-syllable/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129041020-syllable/</guid><description>Syllables are the [see page 3, shortest] stretch of speech, they consist of vowels and consonants.
Words can be:
Term Meaning Monosyllabic Having only one syllable. Polysyllabic Having two or more syllables.</description></item><item><title>Symbolwise Text Compression</title><link>https://mohkale.gitlab.io/brain/20201102003220-symbolwise_text_compression/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102003220-symbolwise_text_compression/</guid><description>A way to compress text which relies on the frequency of symbols.
Use less bits to represent the most frequently used information.</description></item><item><title>Symmetric Relation</title><link>https://mohkale.gitlab.io/brain/20210627012430-symmetric_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627012430-symmetric_relation/</guid><description>A property of a relation where if one variable relates to another \( a R b \) then the other variable [see page 20, must] relate to the original \( b R a \). That is to say \[ \forall a \in A, b \in B ((a R b) \implies (b R a)) \]</description></item><item><title>Symmetric-key Encryption</title><link>https://mohkale.gitlab.io/brain/20210215004504-symmetric_key_encryption/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215004504-symmetric_key_encryption/</guid><description>Describes a Cryptographic System in which the key used for the encryption is the same key that is used for decryption. I.E. \[ \text{Key1} = \text{Key2} \]</description></item><item><title>sync</title><link>https://mohkale.gitlab.io/brain/20211010194452-sync/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010194452-sync/</guid><description>Is a system-call that forces data, that your OS may cache into RAM or other physical memory as a performance improvement, to be written back to the disk. See sync.
Note: Linux, especially, is extreme when it comes to this. All unused memory is used as a giant disk cache.
Warn: in some cases, this sys-call may not do anything anyways.</description></item><item><title>Syntax</title><link>https://mohkale.gitlab.io/brain/20210626235425-syntax/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626235425-syntax/</guid><description>Refers to the rules for writing a language, such as the keywords and symbols of it or what constitutes a valid expression.</description></item><item><title>System</title><link>https://mohkale.gitlab.io/brain/20211002213514-system/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002213514-system/</guid><description>Is a system-call simplifying the execution of a sub-command by wrapping around fork and exec. See system.
At a high level a system provides the functionality of exec but restores the running process back to its working state after the sub-command finishes. It does this by forking and running exec in the child process, making the parent process wait on it.
pid_t out = fork(); if (out &amp;lt; -1) return -1; if (out == 0) { execl(&amp;#34;/bin/sh&amp;#34;, &amp;#34;/bin/sh&amp;#34;, &amp;#34;-c&amp;#34;, &amp;#34;\&amp;#34;ls\&amp;#34;&amp;#34;); exit(1); // For safety.</description></item><item><title>System Boundary</title><link>https://mohkale.gitlab.io/brain/20210911022536-system_boundary/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911022536-system_boundary/</guid><description>Is a UML construct used to [see page 9, divide] use-cases in a use case diagram.
Generally the boundary is drawn as a big box including a subset of the use-cases in a use-case diagram. You can place use-cases outside of the system boundary to mark it as excluded or included in the implementation. You can also use as many boundaries as you want to reference different incremental releases.</description></item><item><title>System Design Interview</title><link>https://mohkale.gitlab.io/brain/20201127003217-system_design_interview/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201127003217-system_design_interview/</guid><description>Is a kind of interview that focuses on developing a system to solve some task given a broad description of the domain. For eg. build a URL shortener? or &amp;quot;build a video streaming site for your mobile device?&amp;quot;
The approach you should take to this process should come in 2 parts.
Analysis Break down and analyse the constraints and use cases of the system.
The goal is to see if you can gather the requirements about the problem at hand, and design a solution that covers them well.</description></item><item><title>Table Diagram</title><link>https://mohkale.gitlab.io/brain/20210911022827-table/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911022827-table/</guid><description>Is a UML model used to design a database table.
It's [see page 5, drawn] the same way as a class except the table name is prefixed by the tag &amp;lt;&amp;lt;table&amp;gt;&amp;gt;, the first box represents table columns and the last box is used for triggers or integrity check functions.
Columns are specified just like class fields with associated types (for example string[30] represents a string with at most 30 characters). You can also prefix column names with key identifiers such as PK for primary key or FK for foreign key.</description></item><item><title>Tail Call Optimisation</title><link>https://mohkale.gitlab.io/brain/20220111114247-tail_call_optimisation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220111114247-tail_call_optimisation/</guid><description>Is an optimisation technique for recursive functions where you can collapse multiple stack frames into a single stack frame that's reused for each recursive call.
def fac(i): if i &amp;lt;= 0: return 1 return i * fac(i - 1) Code Snippet 1: Example of a recursive function that could use tail-call optimisation. tail-call In we have a function defined in terms of itself. Depending on the argument it returns 1 or the multiple of the current value and the function with the current argument take one.</description></item><item><title>Tap Sequence</title><link>https://mohkale.gitlab.io/brain/20210215032031-tap_sequence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215032031-tap_sequence/</guid><description>Are the bits in each state of a LFSR that's used to calculate the feedback-bit.
The choice of tap sequence determines the periodicity for a LFSR and some choices do not give a maximal-period.
The tap-sequence directly defines the linear feedback function. For example [see page 12, here] the first and last bits are the tap-sequence.</description></item><item><title>Target Costing</title><link>https://mohkale.gitlab.io/brain/20201106015634-target_costing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106015634-target_costing/</guid><description>[see page 28, Pricing] a product based on the laws of supply-and-demand.
This is often an approach taken by price-takers. To earn a profit companies focus on controlling costs, setting a target cost that can make the desired profit.
We come up with a target-cost based on the market price and our desired profit, doing whatever we can to keep actual-cost below target-cost to maintain a steady profit.
See the practical example [see page 29, here].</description></item><item><title>Tautalogy</title><link>https://mohkale.gitlab.io/brain/20210627000016-tautalogy/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627000016-tautalogy/</guid><description>Is a proposition that [see page 24, must] be true.
These propositions have a truth table that's always true.</description></item><item><title>TBN-space</title><link>https://mohkale.gitlab.io/brain/20201109202831-tbn_space/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109202831-tbn_space/</guid><description>A coordinate-systems based on Tangent, Bitangent and Normals.</description></item><item><title>TCP</title><link>https://mohkale.gitlab.io/brain/20210429003503-tcp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429003503-tcp/</guid><description>Is a bidirectional protocol used to reliably transmit data between two machines in a network.
TCP is built atop the IP (IPv4/IPv6) protocols, using them for negotiating a connection, which is why it's often referred to as TCP/IP. Any packets sent through TCP must send acknowledgements of the packets it sees back to the sender. If the acknowledgement doesn't arrive within some timeout the sender resends the packet. TCP also attaches a sequence number to each packet so the receiver can re-build the original file in case the packets arrive out of order.</description></item><item><title>Template Method Pattern</title><link>https://mohkale.gitlab.io/brain/20210922051927-template_method/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210922051927-template_method/</guid><description>Is a software design pattern where control algorithms are generalised to common skeleton code with dynamically bound subroutines. Sub-instances can vary the steps as needed.
For example a banking transaction object which performs an abstract transaction and then commits the result.
This pattern uses a general algorithm structure [see page 24, indicating] generic behaviour.</description></item><item><title>Term Manipulation</title><link>https://mohkale.gitlab.io/brain/20201103212333-term_manipulation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201103212333-term_manipulation/</guid><description>The act of preprocessing words from documents to support generalisation. This is often a beginning stage in building an inverted-(/brain/20201103212129-indexing/) for information-retrieval.
It has been [see page 5, observed] that both the most frequent and least frequent words are not the most useful for retrieval. Note: the curve shown above is common across most human languages.</description></item><item><title>Term Weighting</title><link>https://mohkale.gitlab.io/brain/20201103212942-term_weighting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201103212942-term_weighting/</guid><description>A form of term-manipulation where we weight given terms in a query (and/or collection) to better find relevant documents.
We [see page 10, define]:
Name Symbol Description Document Collection \(D\) collection (set) of documents Size of Collection \(\mid D \mid\) Total number of documents in collection Term Frequency \(tf_{w,d}\) Number of times word w occurs in document d Collection Frequency \(cf_w\) Number of times w occurs in collection Document Frequency \(df_w\) Number of documents containing w We also [see page 11, find] that the collection frequency isn't a very good measure of the relevence of a term in a document.</description></item><item><title>Test Coverage</title><link>https://mohkale.gitlab.io/brain/20210926030208-test_coverage/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926030208-test_coverage/</guid><description>Is a [see page 11, measure] of how much of a software system is validated by your tests.
White Box Has full statement coverage on every program node with decision coverage (across all possible branches) and condition coverage (over every boolean sub-expression true/false).
Black Box Includes Equivalence Partition Testing of all distinct set of arguments that trigger different outcomes/exceptions and State Based Testing exercising the complete state-space reaching every state and firing every transition.</description></item><item><title>Text Coding</title><link>https://mohkale.gitlab.io/brain/20201104000449-text_coding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201104000449-text_coding/</guid><description>Determining the output representation of a symbol in a compression scheme given the probability distribution supplied by a model. The general approach is:
Symbols that occur the most frequently should have the shortest code. Symbols that occur the least frequently should have the longest code. Given a set of codewords we can [see page 116, calculate] the expected average code length (bit count) for each symbol in the compressed output.</description></item><item><title>Text Compression</title><link>https://mohkale.gitlab.io/brain/20201029164934-text_compression/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201029164934-text_compression/</guid><description>Lower the size of data by using less bits to represent generally the same information.
This can be:
Compression Description Lossless Original data can be perfectly reconstructed. Lossy Discard low priority information to optimise storage. And has [see page 37, two] methods each using a model/dictionary as a lookup table:
symbolwise dictionary Performance [see page 14, Concerns]:</description></item><item><title>Text Processing</title><link>https://mohkale.gitlab.io/brain/20201001212813-text_processing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201001212813-text_processing/</guid><description>The creation, storage and access of (massive) text in digital form by a computer.
Broca's area is the region of the brain associated with (spoken) language.
[see page 6, Applications] Information Retrieval Deciding relvence of a bunch of documents based on a search query, think Google. Information Extraction Recognise (Specific) information from text. eg. Foo IS A Dog. Text Categorisation Put text into discrete categories, eg. Email into Spam Summarisation Extract essential information from (one or more) text articles.</description></item><item><title>Text Segment</title><link>https://mohkale.gitlab.io/brain/20211002221024-text_segment/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002221024-text_segment/</guid><description>This is where all executable instructions for a process are stored. It's readable but not writable.</description></item><item><title>Texture Atlas</title><link>https://mohkale.gitlab.io/brain/20201109013844-texture_atlas/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109013844-texture_atlas/</guid><description>A collection of multiple textures grouped into a single image.</description></item><item><title>Texture Filtering</title><link>https://mohkale.gitlab.io/brain/20201105143530-texture_filtering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201105143530-texture_filtering/</guid><description>Texture coordinates are specified not on pixel resolution, but as a continuous floating point value. Texture filtering is how OpenGL resolves ambiguous pixel specifications while sampling. If you point to 0.5 and that's not right in the center of a pixel, which color do you use at that point?
Kind Meaning GL_NEAREST Pick the nearest pixel at that point in the texture. GL_LINEAR Interpolates between the point and its surrounding pixels.</description></item><item><title>Texture Mapping</title><link>https://mohkale.gitlab.io/brain/20201027210604-texture_mapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027210604-texture_mapping/</guid><description>Applies a pattern of colour to an object. The challenge of texture mapping is:
.org-center { margin-left: auto; margin-right: auto; text-align: center; } [see page 6, [Projection](COM3503-w05-textures-01)] ([Sampling](/brain/20201105142051-sampling/)) - Given a pixel from a texture where should this pixel be on an objects surface. 2D texture mapping pastes a bitmap onto the surface of an object. 3D texture mapping is like having a pattern/image and then carving an object onto it.</description></item><item><title>Texture Unit</title><link>https://mohkale.gitlab.io/brain/20201105174818-texture_unit/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201105174818-texture_unit/</guid><description>The location (as in shader-location) is where a textures can be found in a shader.
The default texture-unit is 0, meaning that you can reference a uniform texture at this location without assigning it first. For all other texture-units you must first enable them (eg. glActiveTexture(GL_TEXTURE0)) and then bind them glBindTexture(GL_TEXTURE_2D, texture).
OpenGL makes 16 texture units (0-15) available for our use.</description></item><item><title>Textures</title><link>https://mohkale.gitlab.io/brain/20201105164652-textures/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201105164652-textures/</guid><description>A texture is an image that opengl can load and apply onto a surface at runtime.
Different image formats need to be loaded seperately. Writing an image loader for all of these is too time consuming to be practical so we use pre-made libraries for this. The stb_image library is a common choice. We can load an image like so:
int width, height, nrChannels; unsigned char *data = stbi_load(&amp;#34;container.jpg&amp;#34;, &amp;amp;width, &amp;amp;height, &amp;amp;nrChannels, 0); // free with `stbi_image_free(data)`.</description></item><item><title>The Iron Triangle</title><link>https://mohkale.gitlab.io/brain/20210626233316-the_iron_triangle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626233316-the_iron_triangle/</guid><description>Is a [see page 14, triangle] used to model the constraints of project management. It contends that:
The quality is constrained by the projects budget and scope (features). The project manager can trade between constraints. Changes in one constraints necessitates changes in the others to compensate (or quality will suffer).</description></item><item><title>The Painters Algorithm</title><link>https://mohkale.gitlab.io/brain/20201023214420-the_painters_algorithm/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023214420-the_painters_algorithm/</guid><description>A [see page 4, way] to draw a scene by sorting objects based on their distance to the viewpoint, drawing the furthest away object first and then closer objects as you encounter them.
There're quite a [see page 5, few] issues with this algorithm in complex scenes.</description></item><item><title>The Web</title><link>https://mohkale.gitlab.io/brain/20210428235048-the_web/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210428235048-the_web/</guid><description>The [see page 12, web] is a service that runs over the internet, providing support for HTTP/HTML protocol family.</description></item><item><title>Theta Notation</title><link>https://mohkale.gitlab.io/brain/20210628050717-theta_notation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628050717-theta_notation/</guid><description>An asymptotic function which provides a tight [see page 9, upper and lower] bound. A function \( f(n) \) belongs to the set \( \theta(g(n)) \) if it can be sandwiched between \( c_1 g(n) \) and \( c_2 g(n) \) for sufficiently large \( n \).
\begin{align*} \theta(g(n)) = \{ f(n) : &amp;amp; \text{\; there exists constants \;} 0 &amp;lt; c_1 \leq c_2 \text{\; and \;} n_0 \text{\; such that \;} \\</description></item><item><title>Thin Skull Rule</title><link>https://mohkale.gitlab.io/brain/20201121185346-thin_skull_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201121185346-thin_skull_rule/</guid><description>A rule regarding remoteness where the complexity leading to damage isn't relevent so long as the damages themselves where foreseeable.
For example constructing a rhube-goldberg machine to whack someone on the head with a hammer. You may not be able to foresee each individual action leading to the end result, but the end result itself was foreseeable.</description></item><item><title>Thrashing</title><link>https://mohkale.gitlab.io/brain/20210717193226-thrashing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717193226-thrashing/</guid><description>The situation where a storm of high priority interrupts take control of the CPU and prevent the scheduler from allowing any time for any other process.</description></item><item><title>Thread</title><link>https://mohkale.gitlab.io/brain/20211003195449-thread/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211003195449-thread/</guid><description>Short for thread-of-execution, meaning a series of instructions that the CPU has to execute.
Curiously a thread is a process. The core exception being the there's no copying of an existing processes address space when creating a new thread (as you would with fork). Instead multiple threads share the same address space, variables, heap, file descriptors, etc. as their parent process allowing you to access and modify them. Note: Each program gets its first thread free, and can use the pthread_create system call to create more threads.</description></item><item><title>Thread Safety</title><link>https://mohkale.gitlab.io/brain/20210607030359-thread_safety/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607030359-thread_safety/</guid><description>Is the idea of preventing race-condition and ensuring the semantics of a data-structure (or operation) remains consistent when called in a multi-threaded environment.
The common way to enforce thread-safety is by wrapping a mutex-lock around critical sections (sections where only one thread may have access at any time) of our code.
Thread Safe Stack example
#define STACK_SIZE 20 int count; double values[STACK_SIZE]; pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; void push(double v) { pthread_mutex_lock(&amp;amp;m); values[count++] = v; pthread_mutex_unlock(&amp;amp;m); } double pop() { pthread_mutex_lock(&amp;amp;m); double v = values[--count]; pthread_mutex_unlock(&amp;amp;m); return v; } int is_empty() { pthread_mutex_lock(&amp;amp;m); int result = count == 0; pthread_mutex_unlock(&amp;amp;m); return result; } Code Snippet 1: Example of a thread safe (statically sized) stack implementation (without underflow/overflow checks).</description></item><item><title>Threat Modelling</title><link>https://mohkale.gitlab.io/brain/20210430004540-threat_modelling/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430004540-threat_modelling/</guid><description>The [see page 49, first] step in secure software design (part of SDLC), where potential threats are identified and prioritised.
[see page 49, Involves]:
Identifying assets and stakeholders. Consider architecture of application and environment. Brainstorm about known threats. Define security assumptions. Rank threats by risk (roughly \( \text{impact} \times \text{likelihood} \)). Goals and considerations:
Think about security issues early. Understand your requirements better. Decide which threats to respond to.</description></item><item><title>Threat Tree</title><link>https://mohkale.gitlab.io/brain/20210430010449-threat_tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210430010449-threat_tree/</guid><description>A [see page 65, tree] like diagram used to assess that takes a possible exploit and expands into potential vulnerabilities that can be associated with that exploit.
For example:
compromise password How do they get the password? Access an in-use password (through user)? How? Phishing Access from the database? How? Password is in clear-text. They compromised the database? How? SQL injection Access database directly How?</description></item><item><title>Timbre</title><link>https://mohkale.gitlab.io/brain/20210128050028-timbre/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128050028-timbre/</guid><description>The sound-pressure-level at two different frequencies in a sound wave.</description></item><item><title>Time Domain Filtering</title><link>https://mohkale.gitlab.io/brain/20201116225520-time_domain_filtering/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201116225520-time_domain_filtering/</guid><description>A filter applied in the time-domain spectrum.
Classic filters are [see page 2, applied] in the frequency domain, where the filter can be defined by it's frequency-response (the result of applying it). In time-domain we use Difference Equation.</description></item><item><title>Time Invariant Filter</title><link>https://mohkale.gitlab.io/brain/20201116231151-time_invariant_filter/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201116231151-time_invariant_filter/</guid><description>A filter which [see page 3, produces] the same output for the same input, regardless of delays.
That is to say if an input signal x[0] produces y[0], then if x[0] is delayed by 2 seconds than y[0] is also delayed by 2 seconds. That is to say, the filter doesn't depend on the timing of the input to determine its output.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } x[n] =&amp;gt; y[n] x[n-n_0] =&amp;gt; y[n-n_0]</description></item><item><title>Time Value of Money</title><link>https://mohkale.gitlab.io/brain/20210110033924-time_value_of_money/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110033924-time_value_of_money/</guid><description>The concept that money today is not necessarily the same amount as money in the next year. Essentially an investor can invest their current moneys and accrue more, through interest, by next year.
Discounting - given an expected return on investment and a fixed interest rate, discounting is the process by which we determine how much money should be invested now to get the expected return. Say I have a loan opportunity which will yield 10% interest every year and by year 5 I want £133.</description></item><item><title>Timesharing</title><link>https://mohkale.gitlab.io/brain/20210717192004-timesharing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717192004-timesharing/</guid><description>The concept of switching computer processes so quickly that a computer can appear to be doing several things at once.</description></item><item><title>TLD</title><link>https://mohkale.gitlab.io/brain/20210719193433-tld/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210719193433-tld/</guid><description>Is a domain at the highest level of the domain naming system.
For example the domain foo.bar.com has a TLD of .com.</description></item><item><title>TLS</title><link>https://mohkale.gitlab.io/brain/20210429003540-tls/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429003540-tls/</guid><description>Is the newer [see page 39, name] for what was the SSL protocol.
TLS v1.0 is SSL v3.1. TLS v1.2 is current and v1.3 is being rolled out.</description></item><item><title>Topic Detection</title><link>https://mohkale.gitlab.io/brain/20201025200326-topic_detection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025200326-topic_detection/</guid><description>A way to detect the [see page 8, similarity] of documents to group relevent results together.
The general process is:
Issue a search Get back documents Group documents into clusters Show clusters to user</description></item><item><title>Topological Sorting</title><link>https://mohkale.gitlab.io/brain/20210628055140-topological_sorting/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628055140-topological_sorting/</guid><description>Is a linear ordering of all the vertices of a directed acyclic graph such that for each edge \( (u, v) \) where \( u \) appears before \( v \).</description></item><item><title>Tort</title><link>https://mohkale.gitlab.io/brain/20201114182758-tort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114182758-tort/</guid><description>A civil (action brought in civil, not criminal law) wrong for which the remedy is a common law action for Unliquidated Damages.
Torts can be brought not only for a breach of contract or trust, it can be for a violation of a equitable obligation. [see page 3, Kinds]:
Nuisance Trespass Defamation. Libel (written) and slander (spoken) statements that harms a persons reputation. Negligence</description></item><item><title>Total Function</title><link>https://mohkale.gitlab.io/brain/20210627010523-total_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010523-total_function/</guid><description>A total function is [see page 21, defined] for all elements of its domain. That is it accepts and returns a value for all the elements of its domain.</description></item><item><title>Total Order Reflection</title><link>https://mohkale.gitlab.io/brain/20210627014708-total_order_reflection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627014708-total_order_reflection/</guid><description>A relation that is partial order and everything is related to everything else (\( \forall x, y \in A ((x R y) \lor (y R x)) \)). See [see page 14, here].</description></item><item><title>Total Turing Test</title><link>https://mohkale.gitlab.io/brain/20210926210231-total_turing_test/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926210231-total_turing_test/</guid><description>A variant of the Turing-test that also involves a visual aspect, requiring:
Computer Vision: to perceive objects. Robotics: to manipulate objects and move about. The original Turing test doesn't require a physical interaction because such things aren't necessary for intelligence. This test includes them to allow testing of the subjects perceptual abilities.</description></item><item><title>Trademark</title><link>https://mohkale.gitlab.io/brain/20201027164514-trademark/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027164514-trademark/</guid><description>.org-center { margin-left: auto; margin-right: auto; text-align: center; } a mark or device usually attached to goods or services which indicates a connection between those goods or services and the trade mark owner. Use Meaning Origin Tell consumers where goods come from. Guarantee The consistency of quality/safety. Product Differentiation Lets consumers differentiate brands. Advertising Function Protects against free-riding (use of a trademark by someone else) or dilution (lowering quality) of reputation Examples of Trademarks Brand Names Symbols/Logos Shapes (coca-cola) Slogans Sounds Color Scheme (very hard) Celebrity's image (Can't be registerd) Protection See [see page 15, here] for difference in the kinds of protections offered.</description></item><item><title>Transform Centre Architecture</title><link>https://mohkale.gitlab.io/brain/20210906023949-transform_centre_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210906023949-transform_centre_architecture/</guid><description>A software architecture where one controller subsystem manages all the others.</description></item><item><title>Transitive Relation</title><link>https://mohkale.gitlab.io/brain/20210627014415-transitive_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627014415-transitive_relation/</guid><description>Any relation \( R \subseteq A \times A \) is [see page 26, transitive] if \( \forall x, y, z \in A ((x R y) \land (y R z) \implies x R z) \).</description></item><item><title>Translation Lookaside Buffer</title><link>https://mohkale.gitlab.io/brain/20211008232613-translation_lookaside_buffer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008232613-translation_lookaside_buffer/</guid><description>Is an associated cache of most recently used virtual-page to physical-frame lookups.
This essentially stores the result of a page-to-frame translation so that if its referenced again soon after then you can just return the result address instead of having to calculate it again.</description></item><item><title>Trapezium Rule</title><link>https://mohkale.gitlab.io/brain/20210621215952-trapezium_rule/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621215952-trapezium_rule/</guid><description>Approximates the area of a curve over a region by splitting the area into a number of connected trapeziums. This is often used as an alternative to integration.
For example consider a simple straight line curve with no gradient \( y = 5 \). If we want to find the area of the curve we can set \( y = a \) (the start position), step \( a \) until we reach \( b \) and then sum the area of the regions we stepped through together.</description></item><item><title>Travelling Salesman Problem</title><link>https://mohkale.gitlab.io/brain/20210623023741-travelling_salesman_problem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210623023741-travelling_salesman_problem/</guid><description>Is the problem of navigating a graph \( G \) such that you visit every vertex only once and then return to your start point. This is only possible on eulerian graphs.</description></item><item><title>Traversable Network</title><link>https://mohkale.gitlab.io/brain/20210622180314-traversable_network/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622180314-traversable_network/</guid><description>Is a network which can be drawn without taking your pen off the prepare and without covering any edge more than once.
\begin{figure} \centering \begin{tikzpicture} \node (P) [draw, circle] {P}; \node (Q) [draw, circle, right=of P] {Q}; \node (S) [draw, circle, below=of P] {S}; \node (R) [draw, circle, below=of P, right=of S] {R}; \draw (P) -- (Q) (P) -- (R) (P) -- (S) (Q) -- (R) (Q) -- (S) (R) -- (S); \end{tikzpicture} \caption{An example of a non-traversable graph.</description></item><item><title>Tree</title><link>https://mohkale.gitlab.io/brain/20210622174505-tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622174505-tree/</guid><description>Is a connected graph with no cycles. Algorithmically a tree is recursively [see page 4, defined] as a finite set of nodes such that either: The tree is empty (no nodes) or it is composed of a root node, and one or more sub-trees.
A leaf node is a node that has no children. Any other nodes in the tree is an internal node.
The height of a node is defined as the length of the longest path from that node to a leaf node.</description></item><item><title>Tree Traversal</title><link>https://mohkale.gitlab.io/brain/20210628054304-tree_traversal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210628054304-tree_traversal/</guid><description>Refers to the process of [see page 16, enumerating] the nodes of a binary tree.
Pre-order Tree Traversal Is a tree traversal algorithm which yields the current element before branching into the left and right sub-trees.
def pre_order(x): if x is not None: print(x.key) pre_order(x.left) pre_order(x.right) Code Snippet 1: Pre-order tree traversal. In-order Tree Traversal Is a tree traversal algorithm which branches into the left sub-tree, yields the current element and then branches into the right sub-tree.</description></item><item><title>Trespass</title><link>https://mohkale.gitlab.io/brain/20201114183322-trespass/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114183322-trespass/</guid><description>When someone unlawfully enters your land without permission.
To the person Trespassing a persons body directly or indirectly. Eg. kidnapping, assault.</description></item><item><title>Triangle</title><link>https://mohkale.gitlab.io/brain/20210621215704-triangle/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621215704-triangle/</guid><description>Is a polygon with 3 sides.
Right Angled Triangle Is a triangle with one of the 3 angles being \( 90^{\degrees} \).</description></item><item><title>Trigonometric Functions</title><link>https://mohkale.gitlab.io/brain/20210621195436-trigonometric_functions/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621195436-trigonometric_functions/</guid><description>Are real function which relate an angle of a right angled triangle to the ratios of the 2 sides of that triangle.
Sine is classically a trigonometric function which specifies how the height of a circle changes as we move a hypothetical angle across it anti-clockwise from the top-right quadrant. At \( \theta = 360 = 0, \; \sin \theta = 0 \), at \( \theta = 90, \; \sin \theta = 1 \), at \( \theta = 180, \; \sin \theta = 0 \), at \( \theta = 270, \; \sin \theta = -1 \).</description></item><item><title>Trivial File Transfer Protocol</title><link>https://mohkale.gitlab.io/brain/20211010015035-trivial_file_transfer_protocol/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211010015035-trivial_file_transfer_protocol/</guid><description>Is a variant of the FTP protocol built atop UDP.</description></item><item><title>Trojan Horse</title><link>https://mohkale.gitlab.io/brain/20210211224427-trojan_horse/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211224427-trojan_horse/</guid><description>Malware that [see page 4, masquerades] as a friendly program, behaving as expected, but also performing some unexpected actions in the background.
The danger of Trojans is that their commonly [see page 5, executed] with the same permission as the user that invokes them... meaning an admin running a Trojan can give admin access to the Trojan.
Counter-protection You can [see page 6, protect] against Trojan's by:
Scrutinising the program code and verify it has no Trojan behaviour.</description></item><item><title>Trusted Computer Base</title><link>https://mohkale.gitlab.io/brain/20210211225839-trusted_computer_base/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210211225839-trusted_computer_base/</guid><description>A security policy that [see page 7, combines] both of the ways to protect against Trojans by creating two computer systems, one which is tightly protected and assumes no Trojans exist on it (the Trusted Computer Base) and another untrusted system which can only access resources through the TCB under the guidance of a Reference Monitor.
The reference monitor enforces MAC policies (limits the potential for disclosing information). You can't look at the whole system.</description></item><item><title>Tube Harmonics</title><link>https://mohkale.gitlab.io/brain/20201115222310-tube_harmonics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201115222310-tube_harmonics/</guid><description>A tube is a cyllindrical structure with two holes at each end. Sound enters the first end and comes out the other.
A [see page 14, tube] The simplest example of a resonant enclosure. We can [see page 14, calculate] the resonant frequency for such a tube as a measure of the speed of the sound \(v\) and the length of the tube \(L\).
side conditions (fixations) define where minima/maxima are for standing waves.</description></item><item><title>Turing Test</title><link>https://mohkale.gitlab.io/brain/20200704194318-turing_test/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20200704194318-turing_test/</guid><description>The [see page 23, turing test] is a means of determining if a computer can fool a human into thinking it's alive.
Table 1: Listing of the various capabilities of intelligence interrogated by the test. Capability Required To Natural Language Processing Allow communication in English. Knowledge Representation Store/remember what it knows or hears. Automated Reasoning Use stored information to answer questions and draw new conclusions.</description></item><item><title>Type Safety</title><link>https://mohkale.gitlab.io/brain/20210607030250-type_safety/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607030250-type_safety/</guid><description>TODO: Copy over [see page 32, this].</description></item><item><title>UDP</title><link>https://mohkale.gitlab.io/brain/20211009184502-udp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211009184502-udp/</guid><description>Is a connectionless (stateless) protocol built on top of IPv4 and IPv6. It's simple: Decide the destination (address + port) -&amp;gt; Send your packet. The protocol makes no guarantees about whether the packet reached the destination or not.
UDP is fire and forget.
UDP is commonly used when receiving up to date data is more important than receiving all of the data. For example a game may send continuous updates of player positions or a video signal may send picture updates through UDP.</description></item><item><title>Umbra &amp; Penumbra</title><link>https://mohkale.gitlab.io/brain/20201027185321-umbra_and_penumbra/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027185321-umbra_and_penumbra/</guid><description>Refers to regions on a surface affected by a shadow.
Term Meaning Umbra Receiving surface cannot see part of the light source. Penumbra Can see some of the light source, but is partially blocked. Different factors in the light source can cause different sorts of [see page 3, shadows].</description></item><item><title>UML</title><link>https://mohkale.gitlab.io/brain/20210701010944-uml/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701010944-uml/</guid><description>Is a standard design [see page 20, notation] for documenting modern software systems.
Table 1: tbl:tikz-uml-index Section Class Diagram Use Case Diagram State Transition Diagram Sequence Diagram Component Diagrams I endure writing these in latex using the tikz-uml package. In tbl:tikz-uml-index you can find a reference to the documentation for the various sorts of graphs you'd want to build with tikz.</description></item><item><title>UML Constraints</title><link>https://mohkale.gitlab.io/brain/20210926021423-uml_constraints/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926021423-uml_constraints/</guid><description>Is a way to support formal systems design with UML by adding [see page 4, constraints].
Constraints can be applied to both attributes, associations and methods. They are either:
Symbolic: pre-defined constraints such as {unique}, {overlapping}, {disjoint}. or, Expressions: involving attributes and associations {balance &amp;gt;= overdraftLimit}.</description></item><item><title>Unallocated Space</title><link>https://mohkale.gitlab.io/brain/20210415004141-unallocated_space/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210415004141-unallocated_space/</guid><description>The [see page 6, area] of the disk which no longer holds any file information as indicated by the File System.
There may still be data in unallocated space which hasn't been wiped but filesystem is no longer keeping track of it and has marked the area as writable. This could occur for example after formatting (but not zeroing) a drive.</description></item><item><title>Unary Relation</title><link>https://mohkale.gitlab.io/brain/20210627011815-unary_relation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627011815-unary_relation/</guid><description>A N-Ary relation with size 1.
A unary relation over \( X \) is the same as a subset of \( X \)</description></item><item><title>Unicode</title><link>https://mohkale.gitlab.io/brain/20201007152940-unicode/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201007152940-unicode/</guid><description>Unicode is the universal character encoding scheme with a code space divided into [see page 17, 17 planes]. The first 127 code points of unicode are the same as ascii, meaning any valid ASCII files are valid unicode files as well.
Design Principles it has 10 [see page 5, design principles].
Principle Statement [see page 6, Universality] Encodes a single set of chars for all characters for worldwide use.</description></item><item><title>Unique Quantification</title><link>https://mohkale.gitlab.io/brain/20210627010012-unique_quantification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627010012-unique_quantification/</guid><description>Is a form of existential quantification where the predicate is true for [see page 21, exactly] one element. \[ \exists ! x \; P(x) \] This is equivalent to \( \exists x (P(x) \land \neg \exists y (P(y) \land y \neq x)) \).</description></item><item><title>Universal Quantification</title><link>https://mohkale.gitlab.io/brain/20210627005819-universal_quantification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627005819-universal_quantification/</guid><description>Is a quantification \[ \forall x \; P(x) \] which [see page 16, reads] as &amp;quot;for all \( x \) the predicate P(x) holds&amp;quot;. In this expression the free-variable \( x \) is bound by the quantifier \( \forall x \).
If the predicate is true for all values then the truth-set must be the universe of discourse: \( \forall x \; P(x) \iff \mathcal{U} \). If the predicate is true for no value then it must be the empty set: \( \forall x \; \neg P(x) \iff \varnothing \).</description></item><item><title>Universe Set</title><link>https://mohkale.gitlab.io/brain/20210627000933-universe_set/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627000933-universe_set/</guid><description>In set theory we define the [see page 6, universe set] as the set containing all the elements in a problem space. For example when dealing with a problem containing only people the universe set could be the set of all people.</description></item><item><title>Unliquidated Damages</title><link>https://mohkale.gitlab.io/brain/20201114182933-unliquidated_damages/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201114182933-unliquidated_damages/</guid><description>Damages which are not known in advance of a court case. It is determined after the event occurs.</description></item><item><title>Unsupervised Learning</title><link>https://mohkale.gitlab.io/brain/20210206035506-unsupervised_learning/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210206035506-unsupervised_learning/</guid><description>A category of learning algorithms based on training [see page 11, without] labelled sample data. This approach tries to automatically find structure in the data by extracting useful features and analyzing its structure.
For example a program can be trained to identify features that differ from sample to sample and cluster similar samples together.
Samples are supplied as: \[ \{{x}^{1}, {x}^{2}, \ldots, {x}^{p} \} \]
The main goal of unsupervised learning is maximising the accuracy rate of the final program.</description></item><item><title>URL</title><link>https://mohkale.gitlab.io/brain/20210429000352-url/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429000352-url/</guid><description>A global [see page 15, identifier] of network retrievable (example: internet) documents.
.org-center { margin-left: auto; margin-right: auto; text-align: center; } PROTOCOL://[HOSTNAME](/brain/20210719223052-domain/#domain-name)[:PORT]/PATH[?QUERY][#FRAGMENT]</description></item><item><title>Use Case Diagram</title><link>https://mohkale.gitlab.io/brain/20210701011616-use_case_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701011616-use_case_diagram/</guid><description>Is a UML process-view diagram modelling the use cases of a software system.
\begin{figure} \centering \begin{tikzpicture} \umlactor[scale=0.5, y=-4]{Customer}; \begin{umlsystem}[x=4]{ATM System} \umlusecase[x=3]{Validate Customer}; \umlusecase[x=0, y=-2]{Inspect Balance}; \umlusecase[x=4, y=-3]{Withdraw Cash}; \umlusecase[x=2, y=-4]{Request Statement}; \end{umlsystem} \umlactor[scale=0.5, x=11, y=-1]{Bank}; \umlassoc{Customer}{usecase-2}; \umlassoc{Customer}{usecase-3}; \umlassoc{Customer}{usecase-4}; \umlassoc{Bank}{usecase-2}; \umlassoc{Bank}{usecase-3}; \umlassoc{Bank}{usecase-4}; \umlinclude{usecase-2}{usecase-1}; \umlinclude{usecase-3}{usecase-1}; \umlinclude{usecase-4}{usecase-1}; \end{tikzpicture} \caption{Example use case diagram.} \end{figure} Constructs The use case diagram makes use of actors, generalisation (see [see page 19, example]) and use cases. Use cases are drawn as an ellipse with the role in the center.</description></item><item><title>Use Cases</title><link>https://mohkale.gitlab.io/brain/20210626233913-use_cases/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626233913-use_cases/</guid><description>Is a [see page 4, collection] of scenarios depicting how an actor interacts with a system.
A use case is a sequence of related transactions between an actor and a system that yields a result of measurable value... use-cases represent business tasks, not system actions. They must have a measurable business-level objective.
[see page 6, Jacobson, 1994]. To get started [see page 10, documenting] use cases:</description></item><item><title>User Interface Design</title><link>https://mohkale.gitlab.io/brain/20210911153814-user_interface_design/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210911153814-user_interface_design/</guid><description>Refers to the high-level modelling of a user-interface.</description></item><item><title>User Story Points</title><link>https://mohkale.gitlab.io/brain/20210626234537-user_story_points/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626234537-user_story_points/</guid><description>An analysis metric used to [see page 16, measure] the functionality delivered by a system from the point of view of the developers. This involves assigning a relative estimate to each story card collaboratively (through the team).
The scale of difficulty assigned to a story card goes: \( 0, 1, 2, 3, 5, 8, 13, 20, 40, 100 \).</description></item><item><title>V-Model</title><link>https://mohkale.gitlab.io/brain/20210626202306-v_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626202306-v_model/</guid><description>Is an extension of the waterfall model where each development/researching phase has a [see page 43, paired verification] and validation phase.
\begin{figure} \center \begin{tikzpicture}[ nd/.style={draw, rounded corners, minimum height=1cm, minimum width=3cm, fill=white}, line/.style={thick}, ] \node (req) [nd] at ( 0, 0 * -1.25) {Requirements}; \node (spec) [nd] at ( 1, 1 * -1.25) {Specification}; \node (arch) [nd] at ( 2, 2 * -1.25) {Architectural Design}; \node (mod) [nd] at ( 3, 3 * -1.</description></item><item><title>Valence</title><link>https://mohkale.gitlab.io/brain/20201117014748-valence/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201117014748-valence/</guid><description>The sum of the weights of the emotional words in a lexicon based sentiment analysis approach.
-ve valence -&amp;gt; negative text. +ve valence -&amp;gt; positive text.</description></item><item><title>Validation</title><link>https://mohkale.gitlab.io/brain/20210924042226-validation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210924042226-validation/</guid><description>In terms of software engineering is asking the [see page 2, question]: have we build the right system? This is an informal process to check, along with the client, to ensure all the requirements have been met on no functionality is missing.</description></item><item><title>Value Based Pricing</title><link>https://mohkale.gitlab.io/brain/20201106012415-value_based_pricing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106012415-value_based_pricing/</guid><description>Pricing which sets price primarily (not exclusively) according to the perceived/estimated value of a product/service to a customer, rather than according to a customer. See [see page 11, case-study].</description></item><item><title>Variable Cost</title><link>https://mohkale.gitlab.io/brain/20201106014831-variable_cost/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106014831-variable_cost/</guid><description>Costs that vary according to the volume of activity. Contrastingly fixed costs are costs that aren't variable. Producing one more product won't alter these costs.
For example in a restaurant the:
Cost Type Description Managers Salary Fixed Regardless of demand, this will remain the same. Price of Ingredients Variable More customers, more food needs to be bought. You can [see page 14, example] the relation between total cost, total variable cost and total fixed cost.</description></item><item><title>Variable Length Coding</title><link>https://mohkale.gitlab.io/brain/20201102011506-variable_length_coding/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102011506-variable_length_coding/</guid><description>A coding scheme which produces variable length output (eg. a -&amp;gt; 0, b -&amp;gt; 1010).</description></item><item><title>Variance</title><link>https://mohkale.gitlab.io/brain/20210622165918-variance/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622165918-variance/</guid><description>Are measures of the spread or dispersion of a set of data. For example consider the data sets \( 100, 200, 300 \) and \( 199, 200, 201 \). The first data set is more variable than the second.
We define the variance of a population as:
\begin{align} \sigma^2 &amp;amp;= \frac{\sum (x i \mu^2)}{n} \label{eq:variance} \\
&amp;amp;= \frac{\sum x^2}{n} - \mu^2 \end{align}
Note: the variance is written using the square of the \( \sigma \) symbol, meaning we denote variance in-terms of the standard deviation.</description></item><item><title>Variant Flow</title><link>https://mohkale.gitlab.io/brain/20210701021327-variant_flow/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210701021327-variant_flow/</guid><description>The variant flows diverging from the main flow.</description></item><item><title>Vector</title><link>https://mohkale.gitlab.io/brain/20210621220211-vector/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210621220211-vector/</guid><description>Vectors are collections of values organised into an array. They can be used to represent a coordinate-position (position vector) or a direction that something is pointing in (direction vector).
For example you can have 2 position vectors \( A = \begin{pmatrix}3 &amp;amp; 2 &amp;amp; -1\end{pmatrix}^T \), \( B = \begin{pmatrix}5 &amp;amp; 0 &amp;amp; -2\end{pmatrix}^T \), and define the direction vector from \( A \) to \( B \) as \( \vec{AB} = B - A = \begin{pmatrix}2 -2 -1\end{pmatrix}^T \).</description></item><item><title>Vector Space Model</title><link>https://mohkale.gitlab.io/brain/20201014222832-vector_space_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201014222832-vector_space_model/</guid><description>An information retrieval model where we represent each document as a point in a [see page 61, high-dimensional vector space]. With each term in the document being a single dimension (axis). The value of the document at each axis can be determined by the frequency of the term in that document (see [see page 67, here]).
We create a vector for the query as well and then using some model return only the closest \[n\] documents for the query.</description></item><item><title>Venn Diagram</title><link>https://mohkale.gitlab.io/brain/20210622001122-venn_diagram/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622001122-venn_diagram/</guid><description>Is a way to represent the frequency or probabilities of data/events and how they coincide with each other.
\begin{figure} \centering \begin{tikzpicture}[fill=gray] % left hand (1,0) circle (1); \fill (0,0) circle (1); \node at (-0.5, 0) {$A$}; % right hand (0,0) circle (1); \fill (1,0) circle (1); \node at (1.5, 0) {$B$}; % center \node at (0.5, 0) {$C$}; % outline \draw (0,0) circle (1) (1,0) circle (1); % box \draw[thick] (-1.</description></item><item><title>Venture Capital</title><link>https://mohkale.gitlab.io/brain/20210110055758-venture_capital/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210110055758-venture_capital/</guid><description>Long term [see page 11, finance] provided by certain institutions to new or expanding small-to-medium scale companies to exploit relatively high risk opportunities.
More modern forms of VCs include:
Business Angels Crowd funding Peer-to-peer lending</description></item><item><title>Verification</title><link>https://mohkale.gitlab.io/brain/20210627020040-verification/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210627020040-verification/</guid><description>[see page 5, Demonstrating], mathematically, that an implementation indeed respects the specification. This problem asks the [see page 2, question]: have we built the system right? Essentially verify an implementation truly did solve the problem the specification was needed for.
This process emphasises consistency and completeness:
consistency: no operations produced conflicting results. completeness: all possible outcomes properly covered. The goals of verification is to somehow prove that models are correct before coding and ensure their consistent and complete.</description></item><item><title>Vernam Cipher</title><link>https://mohkale.gitlab.io/brain/20210215024903-vernam_cipher/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215024903-vernam_cipher/</guid><description>Is a stream cipher which [see page 3, works] by generating a random bitstream (\( B_i \)) and XORing the plaintext input with the stream (bit-by-bit) to produce the ciphertext.
Decryption works by XORing the ciphertext with the original bitstream \( B_i \) in the same way as was done for the encryption. Note: This requires the entirety of \( B_i \) to be available to the recipient.
Note: If the random-stream is truly random then OTP is truly secure (by shannons-theorem).</description></item><item><title>Vertex Array Object</title><link>https://mohkale.gitlab.io/brain/20201023023530-vertex_array_object/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023023530-vertex_array_object/</guid><description>Is a VBO like construct to store both VBOs and vertex-attributes in a single construct.
Note: A VAO can have share VBOs between multiple VAOs.
This greatly shortens the amount of boilerplate needed to draw something because you don't need to skeep switching VBO bindings and vertex-attrib declarations within the render loop. You can just bind a single VAO.
Creating a VAO As with VBOs, we first need to declare a vertex array object and reference it through an id.</description></item><item><title>Vertex Attributes</title><link>https://mohkale.gitlab.io/brain/20201023022541-vertex_attributes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023022541-vertex_attributes/</guid><description>Vertex attributes refer to the data we pass into vertex shaders. This data comes from memory managed in VBOs.
After declaring and binding a VBO we can declare it as a vertex-attribute pointer.
glVertexAttribPointer( 0, // Location of attribute in shader that we&amp;#39;re referencing. 3, // Size Of The Vector Being Configured (Vec3) for this vertex attribute. GL_FLOAT, // The Kind Of Data Stored In The Vector. GL_FALSE, // Whether we want to normalise the data into [[id:7067ae56-52a3-4049-b4d6-0e647c38a8ba][NDC]].</description></item><item><title>Vertex Buffer Objects</title><link>https://mohkale.gitlab.io/brain/20201023012515-vertex_buffer_objects/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023012515-vertex_buffer_objects/</guid><description>Data (vertices) allocated on the GPU.
We send data from our program to the GPU so that it can be processed without slow transfers between the GPU and the CPU. This is generally the first stage in the drawing something.
Once in the GPU the vertex shader has near instant access to data.
Creating a VBO We create a buffer and access it through an id.
unsigned int VBO; glGenBuffers(1, &amp;amp;VBO); OpenGL also needs to know the kind of buffer this object points to.</description></item><item><title>Vertex Normal</title><link>https://mohkale.gitlab.io/brain/20201107225739-vertex_normal/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201107225739-vertex_normal/</guid><description>A [see page 13, normal] is a vector that is perpendicular to the 'underlying' surface at that point.
They are used to add depth (facing outward or inward) related information to a mesh.
This is divided into 2 kinds of normals. The vertex normal is applied to each vertex in a mesh, whereas a polygon normal is applied only at the center of a polygon.
The way to calculate a normal varies from [see page 14, shape to shape] and for [see page 15, arbitrary polygons].</description></item><item><title>Vertex Projection</title><link>https://mohkale.gitlab.io/brain/20201027190301-vertex_projection/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027190301-vertex_projection/</guid><description>[see page 6, Projects] an object to the ground. I.E. project rays of light from a light source to the ground through an object to get a shadow.
This approach is simple and can create exact shadows but only works for a flat plane and doesn't shadow the object itself. A bunnies ears won't cast a shadow on it's back with vertex projections.</description></item><item><title>View Volume</title><link>https://mohkale.gitlab.io/brain/20201106231618-view_volume/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201106231618-view_volume/</guid><description>The region between the near-and-far clipping planes in clip space.
The view volume gives us our [see page 22, 3D screen space], a pyramid shaped structure which lets us easily clip pixels outside of it.
Note: We optimise the check for whether something is within the view frustum by using a box model rather than the actual pyramid shape.
Warn: We distort the box while rendering which causes a [see page 23, noticeable difference] between rendering something in view space and 3D screen space</description></item><item><title>Virtual Disk Memory</title><link>https://mohkale.gitlab.io/brain/20210717194651-virtual_memory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210717194651-virtual_memory/</guid><description>Is the memory-management technique of keeping only a small working set of a processes data in memory and keeping the remaining state in a special swap-space area on your hard disk.
This is valuable because for some large programs keeping them all in memory is impractical.
In the background the OS is constantly moving blocks of data between the memory and the swap space to maintain the illusion that the process has a much larger memory store than is actually physically available at any given point in time.</description></item><item><title>Virtual Machine</title><link>https://mohkale.gitlab.io/brain/20220201143221-virtual_machine/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220201143221-virtual_machine/</guid><description>Is an Operating System running within an operating system. Essentially the user uses software to construct virtual hardware and then spins up a new OS within that hardware, passing inputs and outputs between the users machine and the VM OS. This makes virtual machines essentially emulators for other operating systems.</description></item><item><title>Virtual Memory</title><link>https://mohkale.gitlab.io/brain/20211008233530-virtual_memory/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211008233530-virtual_memory/</guid><description>Is the modern approach to memory-management for a process. Each process in a system sees the systems memory as a continuous range that's all available to it. In reality system memory is chunked into virtual memory, meaning when a process references address 1234, it may be directed to address 1876482 on the actual machine hardware.
Nowadays processes are rarely (only on embedded devices) given direct access to physical memory. Instead processes are isolated into virtual memory, where no process can access another processes memory.</description></item><item><title>Visible Surface Ray Tracing</title><link>https://mohkale.gitlab.io/brain/20210105025433-visible_surface_ray_tracing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210105025433-visible_surface_ray_tracing/</guid><description>Using rays to render a scene.
[see page 6, Requires]:
[see page 7, Initial direction] of the ray: differs for each pixel. [see page 8, Hidden surface removal]: we only care about the front-most pixel. [see page 9, Shading]: Essentially just apply phong (or Blinn-Phong) shading. See [see page 14, final algorithm].
Shadows We can extend shading to allow [see page 10, shadowing] by sending a ray from each intersected surface to each light-source to detect whether that surface is blocked out by some other object.</description></item><item><title>Vocal Cords</title><link>https://mohkale.gitlab.io/brain/20210129001416-vocal_cords/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129001416-vocal_cords/</guid><description>Folds that're placed directly in front of the lungs (before the larynx). These flaps rapidly open and close to produce small pulses of air from the air-pressure exiting the lungs.
This rapid opening and closing is often termed the Bernoulli affect.
The rate of this oscillation is called the fundamental frequency (\(F_x\) or \(F_0\)) and influences the pitch of the voice.
Mechanics The acoustic output from this process doesn't result in a pure tone, it's more of a hard edged [see page 5, graph].</description></item><item><title>Vocal Tract</title><link>https://mohkale.gitlab.io/brain/20210129004403-vocal_tract/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210129004403-vocal_tract/</guid><description>The track leading from the end of the larynx upto the mouth. It works as a resonator (with a complex shape) that through articulators changes it's shape to modify resonant characteristics.
See all [see page 2, resonant-cavities].</description></item><item><title>Vocoder</title><link>https://mohkale.gitlab.io/brain/20201102180146-vocoder/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102180146-vocoder/</guid><description>[see page 14, Voice Coder] - Pass input speech through a filter bank to get a series of bands, then re-synthesize the signal after transmission by passing back through the filter bank.
Analyse in certain frequency bands and only transmit the output of those bands. Basically group frequencies together (or calculate them) into bands and then store these discrete groups. You need only as many bits as you have bands.</description></item><item><title>Voice Onset Time</title><link>https://mohkale.gitlab.io/brain/20201020221144-voice_onset_time/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020221144-voice_onset_time/</guid><description>Is the see page 14, gap between the start of a plosive vowel and the release of the pressure (energy) leading to the vowels release.</description></item><item><title>Volume Boot Record</title><link>https://mohkale.gitlab.io/brain/20210811033816-volume_boot_record/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210811033816-volume_boot_record/</guid><description>Is part of a storage device or partition containing machine code for bootstrapping programs stored on other parts of the hard-disk. On an unpartitioned device it is the first sector, otherwise it is the first sector of an individual partition with the first sector being the master boot record.</description></item><item><title>Von-Hann Window</title><link>https://mohkale.gitlab.io/brain/20201109224341-von_hann_window/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109224341-von_hann_window/</guid><description>A windowing-function defined as a [see page 13, smooth curve].
\[ w_{Hn}[n] = \frac{1}{2} \times (1 - cos(\frac{2 \pi n}{L})) \]</description></item><item><title>von-Neumann Architecture</title><link>https://mohkale.gitlab.io/brain/20211125225444-von_neumann_architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211125225444-von_neumann_architecture/</guid><description>TODO
von-Neumann Languages A language based on von-Neumann Architecture. Examples: Fortran, C, C++, python, ruby, Java.</description></item><item><title>Vowels</title><link>https://mohkale.gitlab.io/brain/20201020203400-vowels/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201020203400-vowels/</guid><description>Sound segments produced without any obstruction in the configuration of the vocal tract. In english the vowels are AEIOU.
The formal definition is:
Sounds articulated by raising the front or the back of the tongue towards the roof of the oral cavity or shaping the lips. Vowel Quality [see page 15, Many] languages distinguish between:
Rounded/Unrounded vowels long/short vowels oral/nasalised vowels vowel glides (Monopthongs and Dipthongs) The quality of a vowel can be indicated by:</description></item><item><title>Waterfall Model</title><link>https://mohkale.gitlab.io/brain/20210626201703-waterfall_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626201703-waterfall_model/</guid><description>Is a predictive design model the follows a linear flow from requirements through to implementation, deployment and maintenance.
\begin{figure} \centering \begin{tikzpicture}[nd/.style={draw, rounded corners}, line/.style={thick}] \node (req) [nd] {Requirements}; \node (design) [nd, below right=10pt of req] {Design} edge [&amp;lt;-, line] (req); \node (imp) [nd, below right=10pt of design] {Implementation} edge [&amp;lt;-, line] (design); \node (ver) [nd, below right=10pt of imp] {Verification} edge [&amp;lt;-, line] (imp); \node (dep) [nd, below right=10pt of ver] {Deployment} edge [&amp;lt;-, line] (ver); \node (maintenance) [nd, below right=10pt of dep] {Maintenance} edge [&amp;lt;-, line] (dep); \end{tikzpicture} \caption{The waterfall design model.</description></item><item><title>Waterfall with Feedback</title><link>https://mohkale.gitlab.io/brain/20210626201915-waterfall_with_feedback/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210626201915-waterfall_with_feedback/</guid><description>Is a variant of the waterfall model that supports [see page 38, feeding] data from each phase back to the previous phase.
\begin{figure} \centering \begin{tikzpicture}[ nd/.style={draw, rounded corners}, line/.style={thick}, bl/.style={bend left=25}, br/.style={bend right=25} ] \node (req) [nd] {Requirements}; \node (design) [nd, below right=10pt of req] {Design} edge [&amp;lt;-, line, br] (req) edge [-&amp;gt;, line, bl] (req); \node (imp) [nd, below right=10pt of design] {Implementation} edge [&amp;lt;-, line, br] (design) edge [-&amp;gt;, line, bl] (design); \node (ver) [nd, below right=10pt of imp] {Verification} edge [&amp;lt;-, line, br] (imp) edge [-&amp;gt;, line, bl] (imp); \node (dep) [nd, below right=10pt of ver] {Deployment} edge [&amp;lt;-, line, br] (ver) edge [-&amp;gt;, line, bl] (ver); \node (maintenance) [nd, below right=10pt of dep] {Maintenance} edge [&amp;lt;-, line, br] (dep) edge [-&amp;gt;, line, bl] (dep); \end{tikzpicture} \caption{The waterfall design model with feedback.</description></item><item><title>Wavelength</title><link>https://mohkale.gitlab.io/brain/20210128050239-wavelength/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210128050239-wavelength/</guid><description>The distance between two adjacent Maxima in a wave.</description></item><item><title>Weak AI</title><link>https://mohkale.gitlab.io/brain/20210926204538-weak_ai/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210926204538-weak_ai/</guid><description>The weak approach to AI refers to the old-fashioned style of artificial intelligence which involved stringing together elementary reasoning steps or exploring relatively large search spaces to find optimum solutions. This is called weak AI because it's shown not to scale to larger problem instances.</description></item><item><title>Web App Security</title><link>https://mohkale.gitlab.io/brain/20210429005504-web_app_security/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210429005504-web_app_security/</guid><description>Refers to the class of security problems targeting web applications.
The [see page 2, goals] are:
Allow users to safely browse websites without incurring harm. Support secure web applications, being on the web should be just as secure as a non-web based application. We [see page 6, consider]:
Classic web attacker: just someone who sets up a malicious website that the victim can visit. They can't control the network.</description></item><item><title>Web Services Pipeline</title><link>https://mohkale.gitlab.io/brain/20210908013319-web_services_pipeline/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210908013319-web_services_pipeline/</guid><description>Is the most common software architecture for CGI based web [see page 13, applications].
In this model the web-browsers uses HTML forms to pass URL-encoded strings to a CGI program, which commonly fetch or modify data in the database, and then returns a response. There's generally a high level of coupling across the layers.
\begin{figure} \centering \begin{tikzpicture}[ every text node part/.style={align=center, rectangle}, pkg/.style={scale=1.6}, line/.style={very thick, dashed}] \begin{umlpackage}[pkg]{Web}\end{umlpackage} \begin{umlpackage}[pkg, right=1.2cm of Web]{CGI}\end{umlpackage} \begin{umlpackage}[pkg, right=1.</description></item><item><title>Weighted Graph</title><link>https://mohkale.gitlab.io/brain/20210622173954-weighted_graph/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210622173954-weighted_graph/</guid><description>A graph that associates a weight or value with each edge.</description></item><item><title>White Noise</title><link>https://mohkale.gitlab.io/brain/20201027000537-white_noise/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201027000537-white_noise/</guid><description>A [see page 12, completely random] stochastic signal.
The value of a signal at time \(t\) gives no information about it at time \(t+n\).
Note: Perfect white noise has a constant see page 13, spectral density. Every frequency of sound is present throughout the speach signal, just at (slightly) different amplitudes.
Gaussian White Noise Plot the [see page 15, probability] of white noise by amplitude. I.E. amplitudes with a large Y value are more likely than amplitudes with a low Y value.</description></item><item><title>Windowing</title><link>https://mohkale.gitlab.io/brain/20201110190238-windowing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201110190238-windowing/</guid><description>Refers to the process of [see page 16, applying] a windowing function to a series of signal inputs before interpreting them as samples (or speech-frames, specifically in WOLA).
Think of it:
Take 8 samples. Apply the window and return the result Take 8 more samples. Of course samples can overlap.</description></item><item><title>Windows Forensics</title><link>https://mohkale.gitlab.io/brain/20210318005524-windows_forensics/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210318005524-windows_forensics/</guid><description>OS Forensics targeting the windows operating system. The most [see page 2, widely] used OS as of now.
Registry Each user profile will have its own registry hive (example: NTUSER.DAT).
Windows registry is separated into different [see page 7, hives] such as:
Hive Description HKEY_LOCAL_MACHINE\SYSTEM:\system32\config\system Info about system, hardware config, etc. HKEY_LOCAL_MACHINE\SYSTEM:\system32\config\security Path and password information HKEY_LOCAL_MACHINE\SYSTEM:\system32\config\sam Security accounts monitor, logon info about user HKEY_LOCAL_MACHINE\SYSTEM:\system32\config\software Applications installed and default settings HKEY_USERS\UserProfile:\winnt\profiles\username User accounts HKEY_USERS.</description></item><item><title>Windows Registry</title><link>https://mohkale.gitlab.io/brain/20210318005622-windows_registry/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210318005622-windows_registry/</guid><description>The [see page 6, registry] is a configuration/storage mechanism (database) for the windows OS.</description></item><item><title>Word Size</title><link>https://mohkale.gitlab.io/brain/20210718010421-word_size/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210718010421-word_size/</guid><description>Is the computers preferred size for moving units of information around. Technically the word size is the width of your processors registers, I.E. the holding area your processor uses to do arithmetic and logical calculations.
When a computer is said to be 32-bit or 64-bit it is referencing the word size.
The word size also directly affects the addressable address space of a process, meaning it also affects the number of bits required to maintain a pointer to some area of memory.</description></item><item><title>Working Capital</title><link>https://mohkale.gitlab.io/brain/20201021171556-working_capital/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201021171556-working_capital/</guid><description>Capital is \(Assets - Liabilities\).
Working capital is \(Current Assets - Current Liabilities\).
Working Capital Management Good WC management means a company can pay its debts as the fall due. A business that fails to do this will go bankrupt.
[see page 21, Involves]:
not holding too much inventory for too long (see holding-period). Good collection policy. Get payment ASAP from customers (see Collection Period). Prompt Payment. Pay Suppliers on time and too contract (see payment period).</description></item><item><title>Writing Systems</title><link>https://mohkale.gitlab.io/brain/20201004163044-writing_systems/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201004163044-writing_systems/</guid><description>Also known as a Script.
A system of more or less permanent marks used to represent an utterances in such a way that it can be recovered more or less exactly without the intervention of the utterer. Languages need not have a single writing system, japanese for example:
Writing System Source/Purpose Kanji From Chinese Hiragana For grammatical Particles Katakana For loan words from other languages Arabic For numerals Classification can be done along a number of dimensions:</description></item><item><title>Xft</title><link>https://mohkale.gitlab.io/brain/20210915160339-xft/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210915160339-xft/</guid><description>Is a standard for font specifications for Xorg.
Xft uses a pattern of the form
.org-center { margin-left: auto; margin-right: auto; text-align: center; } `[-][,[-fallback-size]...][:=...]` where name=value pairs can be used to provide arbitrary options for the font lookup engine. Xorg will then search for the font most closely matching the options you provide and then return it. Note: In the case where you specify multiple fallback fonts, the options will be applied to every font in turn to pick a match.</description></item><item><title>XOR</title><link>https://mohkale.gitlab.io/brain/20210215025121-xor/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210215025121-xor/</guid><description>Is a bitwise operation defined by the truth-table:
A B \( A \oplus B \) 0 0 0 1 0 1 0 1 1 1 1 0 From the above you can observe that an XOR is equivalent to: \[ A \xor B = (A \lor B) \land \neg (A \land B) \]
We can also observe the cancellation property: \[ A \xor B \xor B = A \] Which can be extended as the negation rule: \[ A \xor B = C \rightarrow A \xor B \xor C = 0 \]</description></item><item><title>Xorg</title><link>https://mohkale.gitlab.io/brain/20210915160433-xorg/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210915160433-xorg/</guid><description>Is the most popular display server for linux.</description></item><item><title>XSS</title><link>https://mohkale.gitlab.io/brain/20210607055230-xss/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210607055230-xss/</guid><description>Is a security attack targeting web applications using code injection to [see page 9, execute] arbitrary code on the client-side (web browser). It can be used for stealing cookies, session-tokens and other sensitive information.
See [see page 7, consequences]. See [see page 8, OS vs. Browser] analogies and primitives.
XSS generally works by delivering the malicious script to the victim in some form and having them execute it on load.</description></item><item><title>Yellow Key</title><link>https://mohkale.gitlab.io/brain/20220228173809-yellow_key/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20220228173809-yellow_key/</guid><description>Are categories for securities pioneered by Bloomberg. Historically Bloomberg keyboards had dedicated keys for each of these categories and these keys were colored yellow: thus, Yellow Key.
Table 1: Listing of the various Yellow Keys. Yellow Key Shortcut Description Govt &amp;lt;F2&amp;gt; Government Bonds Corp &amp;lt;F3&amp;gt; Corporate Bonds, CDS Mtge &amp;lt;F4&amp;gt; Mortgages M-Mkt &amp;lt;F5&amp;gt; Money market Muni &amp;lt;F6&amp;gt; Municipals and state bonds Pfd &amp;lt;F7&amp;gt; Preferred securities Equity &amp;lt;F8&amp;gt; Equities Comdty &amp;lt;F9&amp;gt; Commodities &amp;amp; Futures Index &amp;lt;F10&amp;gt; Generic interest rates, Economic indices such as CPI, GDP, Equity, Indices Curncy &amp;lt;F11&amp;gt; Foreign currency</description></item><item><title>Z-Plane</title><link>https://mohkale.gitlab.io/brain/20201117002344-z_plane/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201117002344-z_plane/</guid><description>A representation of the plane of the z-transform in both real and imaginary parts as a [see page 9, circle].
You can visualise the z-plane as a unit-circle. We can place Poles &amp;amp; Zeros around the circle and use them to define a filter function. The displacement of the pole/zero from the origin determines how wide the filter is (the range of frequencies at that point it lets through or blocks) and rotation around it determines the frequency-response (the position of the band) of the filter.</description></item><item><title>Z-Plane Transfer Function</title><link>https://mohkale.gitlab.io/brain/20210131013027-z_plane_transfer_function/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20210131013027-z_plane_transfer_function/</guid><description>Is a [see page 7, reordering] of the z-transform function to find z-domain-transfer-function which characterises the behaviour of the filter in terms of it's output and input when \(H[Z]\) is equivalent to the fourier-transform.
\[ H[z] = \frac{Y[z]}{X[z]} \]
Term Meaning \( H[z] \) The z-domain transfer function \( Y[z] \) The output of a linear time domain filter \( X[z] \) The input to the filter to get \( Y[z] \) See [see page 8, common Z-transform pairs], I.</description></item><item><title>Z-Transform</title><link>https://mohkale.gitlab.io/brain/20201116235535-z_transform/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201116235535-z_transform/</guid><description>A power-series [see page 6, representation] of a discrete-time sequence.
It decomposes a time-domain signal into a series of inputs each multiplied be decreasing increments of powers of \(z\) (begins with \(z^0\), \(z^{-1}\), etc.). We write the Z transform as \[ X(z) = \sum_{n = - \infty}^{\infty}{x[n] \times {z}^{-k}} \]
For example for the sequence:
\begin{align*} x &amp;amp;=&amp;amp; x[0], x[1], x[2], x[3] \
X(z) &amp;amp;=&amp;amp; x[0]\times {z}^{0} + x[1]\times {z}^{-1} + x[2]\times {z}^{-2} + x[3]\times {z}^{-3} \end{align*}</description></item><item><title>Zbuffer</title><link>https://mohkale.gitlab.io/brain/20201023214846-zbuffer/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201023214846-zbuffer/</guid><description>An image/screen space algorithm.
Employs 2 [see page 7, buffers]:
Buffer Meaning Color Buffer The color for each pixel on the screen. ZBuffer The depth into the screen for each pixel in the color buffer. The basic idea behind the algorithm is keep a copy of the entire screen in memory and keep trying to draw objects onto it.</description></item><item><title>Zero Crossing Rate</title><link>https://mohkale.gitlab.io/brain/20201109220522-zero_crossing_rate/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201109220522-zero_crossing_rate/</guid><description>The [see page 6, number of times] the zero axis is crossed in one speech frames.
Note: This value is large for unvoiced speech.</description></item><item><title>Zero Order Model</title><link>https://mohkale.gitlab.io/brain/20201102010932-zero_order_model/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201102010932-zero_order_model/</guid><description>A text-compression model which ignores the preceding context.</description></item><item><title>Zombie Process</title><link>https://mohkale.gitlab.io/brain/20211002211035-zombie_process/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20211002211035-zombie_process/</guid><description>Is a process that has exited but still has an entry in the kernels process table.
This occurs for the child-processes where an entry is still needed to allow the parent process to read its child's exit status. Once you wait on the process its entry is removed from the process table and it's known as a reaped process.
If a long running process never waits on its child then it may lose the ability to fork.</description></item><item><title>Zone Indexes</title><link>https://mohkale.gitlab.io/brain/20201025200005-zone_indexes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://mohkale.gitlab.io/brain/20201025200005-zone_indexes/</guid><description>Group concepts using metadata (eg. from semantic web) and then allow structured queries over this data. We build inverted indexes within a limited zone (eg. Name=shakespeare and year=1601).
This lets us query over semantic concepts rather than general terms.</description></item></channel></rss>