This is a similar concept, but more complicated. A vertex can be connected to any number of edges. So edge adjacency is not a 1:1 parallel.

Seeing as an edge can only touch two members, their adjacency is directly correlated to them having a shared edge

much like a set order, describes the number of members

Fanout \(\text{exchanges}\) ignore routingKey, as they contact all all channels bound to them.

When using a direct \(\text{exchange}\), or an auto-generated direct \(\text{exchange}\), the routingKey is used to contact a \(\text{queue}\) of specified name.

Each source \((\text{exchange})\) needs a \(\text{binding}\) in order to connect to a destination \((\text{queue})\).

$$\text{exchange } E ~~_{\large{~~\rightarrow}}^{\text{binding}}~ \text{queue } Q $$

\(\text{bindings}\) can be added to a \(\text{channel}\) using queueBind:

channel.queueBind(queueName,
                  exchangeName, 
                  routingKey);

Every \(\text{subscriber}\) should be declared to have it's own \(\text{queue}\). These \(\text{queues}\) need certain parameters in order to be temporary:

queueName: uniqueId
durable: false;
exclusive: true;
autoDelete: true;

These \(\text{queues}\) can be created with other, special parameters if necessary, along with those listed above. Otherwise, they are easiest to create by the simple method: channel.queueDeclare().

Nameless exchange: when an "" \(\text{exchange}\) name is not specified, basicPublish will instead try and route \(\text{messages}\) directly to a \(\text{queue}\) with the name given as routingKey.

An \(\text{exchange}\) can be defined by its Exchange Type rules to address a list of queues, or to address none.

\(\text{producers}\) send messages to \(\text{exchanges}\), who then forward those messages to \(\text{queues}\).

Any given \(\text{producer}\) doesn't need to know which \(\text{queues}\) its messages will be directly forwarding to, just which \(\text{exchange}\) it is contacting to do that forwarding.

If an autoAck consumer becomes overloaded with messages, it may form a TCP backlog and begin dropping messages. These will not be registered as nack by RabbitMQ, and will not be re-queued for re-delivery.

autoAck or the "fire-and-forget" model is not safe for workloads, but can be used in high throughput environments with very low complexity of work per message.

Messages are delivered with Unique Identifiers as delivery tag

If autoAck is disabled, manual ack becomes a requirement. We can, then, also manually nack or reject if conditions for ack are not met.

Declaring channel.basicQos(1) on each worker forces a near-random distribution of work. If each worker is constantly occupied, this distribution becomes normalized and all workers receive even work loads.

Once a \(\text{queue }Q\) has been initially declared, it can not be re-declared. So, get your queue parameters right before you get to prod.

On a \(\text{queue }Q\), \(_{\text{subscripts}}\) will represent enqueued messages, and \(^{\text{superscripts}}\) will represent a number of sent but unacked messages.

A \(\text{worker }1\), a type of \(\text{consumer}\), can only process 1 \(\text{message }M_1\) at any time. It will then manually send an \(\text{ACK}\) to demonstrate it has completed it's task and is free for another \(\text{message }M_2\).

Triple dots \(\cdots\) represent down time where a \(\text{queue }Q\) either has no queued \(\text{messages}\) or it is waiting for an active \(\text{consumer}\) to receive \(\text{messages}\).

EX: Given 3 time intensive tasks and 2 workers: $$ \text{producer } P ~~_{\normalsize\rightarrow}^{3M}~ \text{queue }Q_0\ \text{queue }Q3 ~~{\normalsize\rightarrow}^{M_1}~ \text{worker }1\ \text{queue }Q2^1 ~~{\normalsize\rightarrow}^{M_2}~ \text{worker }2\ \text{queue }Q1^2 ~\cdots\ \text{worker }1 ~~{\normalsize\rightarrow}^{\text{ACK } M_1}~ \text{queue }Q_1^2\ \text{queue }Q1^1 ~~{\normalsize\rightarrow}^{M_3}~ \text{worker }1\ \text{queue }Q0^2 ~\cdots\ \text{worker }2 ~~{\normalsize\rightarrow}^{\text{ACK } M_2}~ \text{queue }Q_0^2\ \text{queue }Q0^1 ~\cdots\ \text{worker }1 ~~{\normalsize\rightarrow}^{\text{ACK } M_3}~ \text{queue }Q_0^1\ \text{queue }Q_0 ~\cdots\ $$

There are two \(\text{workers: } 1, 2\) and one \(\text{queue }Q\). \(\text{queue }Q\) contains one \(\text{message }M_1\) which has a long run time.

\(\text{worker } 1\) is about to go offline. It will not complete it's transaction of work, and will not \(\text{ACK}\) that it has received the message. Instead, when \(\text{worker }1\) goes offline, it will send a basic \(\text{NACK}\) response and \(\text{queue }Q\) will know to re-queue \(\text{message }M_1\).

$$ \text{queue }Q_1 ~~_{\normalsize\rightarrow}^{M_1}~ \text{worker }1\\ \text{queue }Q_0^1 ~\cdots\\ \text{worker }1 ~~_{\normalsize\rightarrow}^{\text{NACK } M_1}~ \text{queue }Q_0^1\\ \text{queue }Q_1 ~~_{\normalsize\rightarrow}^{M_1}~ \text{worker }2\\ \text{queue }Q_0^1 ~\cdots\\ \text{worker }2 ~~_{\normalsize\rightarrow}^{\text{ACK } M_1}~ \text{queue }Q_0^1\\ \text{queue }Q_0 ~\cdots $$

Lisp if is only usable if there are no else if conditions. All else if statements must be written in the form of a cond switch.

if statements => case analysis

<div /> elements are display: block

<span /> elements are display: inline

Note: childNodes may only be looped over by their indices, as they are not a typical array.

Note: the children property works similarly, but only for elements where nodeType === Node.ELEMENT_NODE;

very distinct from the SUB model.

Some objects need to stay in the DOM, even when not in view. This may require an ng-show as opposed to an ng-if. Alternatively, as long as the object data does not need to be reloaded from the back end, the object could be re-instantiated on the front end.

Well yes, but actually no. MS Edge is just a re-skin of IE which is still trapped in its legacy code base.

For instance, not this morning I ran into a bug where MS Edge and IE add in non-standard X marks in their forms: https://developer.mozilla.org/en-US/docs/Web/CSS/::-ms-clear

Finally some HTML to accompany our JS

async function Promise_all(promises) {
  let all = []; let sat = true;
  for (let i = 0; i < promises.length; i++) {
    await promises[i]
      .then((result) => { all.push(result); })
      .catch((result) => { sat = false; }); }
  return new Promise((resolve, reject) => {
    if (sat) { resolve(all); } }); }

Good Question: It may be beneficial to include else reject() statements in the Promises:

async function locateScalpel(nest) {
  let current; let next = nest.name;
  while (current != next) {
    current = next;
    next = await anyStorage(nest, current, "scalpel"); }
  return next; }

function locateScalpel2(nest, source) {
  if (source === undefined) { source = nest.name; }
  return anyStorage(nest, source, "scalpel").then( (result) => {
    if (result === source) { return result; }
    else { return locateScalpel2(nest, result); } }); }

flooding is a bad practice, even when all nodes need to receive a message. If a network's structure gets cached (either at one centralized server node or at every node in the network) there are much more efficient methods for node to node communication.

Promise.resolve().then()

This is overall a better approach to imports, here is a link to some documentation:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import

This edition of the book is rather dated, and CommonJS is not supported by ECMA standards. But for reference:

https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules

Clearly defined dependencies can help you navigate a complicated app structure to find where bugs can originate from.

structure-less programs are as applicable as children and as malleable as old folks.

New Verify Function.

NOTE: make sure to keep g global enabled

// Fill in the Following Excercises

verify(/.../g,
       ["my car", "bad cats"],
       ["camper", "high art",]);
verify(/.../g,
       ["pop culture", "mad props"],
       ["plop", "prrrop"]);
verify(/.../g,
       ["ferret", "ferry", "ferrari"],
       ["ferrum", "transfer A"]);
verify(/.../g,
       ["how delicious", "spacious room"],
       ["ruinous", "consciousness"]);
verify(/.../g,
       ["bad punctuation ."],
       ["escape the period"]);
verify(/.../g,
       ["hottentottententen"],
       ["no", "hotten totten tenten"]);
verify(/.../g,
       ["red platypus", "wobbling nest"],
       ["earth bed", "learning ape", "BEET"]);


function verify(regexp, yes, no) {
  //ignore unfinished excercises
  if (regexp.source == "...") return;
  findStrings(regexp, yes, true);
  findStrings(regexp, no, false); }
function findStrings(regexp, strings, yes) {
  let found = {}; let not_found = new Set();
  for (let input of strings){
    let selection = {}; let match;
      while (match = regexp.exec(input)) {
        selection[match.index] = match[0]; }
    if(Object.keys(selection).length === 0){
      not_found.add(input);
    } else { found[input] = selection; } }
  if (Object.keys(found).length > 0) {
    console.log(check(yes), "Matched:  ", found); }
  if (not_found.size > 0) {
    console.log(check(!yes), "Unmatched:", setPrint(not_found)); } }
function check(yes){
  if (yes) { return "✔️"; } else { return "❌"; } }
function setPrint(set){
  let line = "{";
  for (let item of set.keys()) { line+= item +", "; }
  return line.slice(0,-2)+"}"; }

let sticky = /abc/y;
sticky.lastIndex = 4;
console.log(sticky.exec("xyz abc"));
console.log(sticky.lastIndex);

confused screaming

in most use cases, the regexp would act more intentionally (and bug out less) using a non-greedy operator

box should really be a class declaration, but we'll let it slide for today

const box = {
  locked: true,
  unlock() { this.locked = false; },
  lock() { this.locked = true;  },
  _content: [],
  get content() {
    if (this.locked) throw new Error("Locked!");
    return this._content; } };

function withBoxUnlocked(body) {
  let locked = box.locked;
  try {
    box.unlock();
    body();
  } finally {
    if (locked){ box.lock(); } } }

// function calls
withBoxUnlocked(() => { box.content.push("gold piece"); });
box.unlock();
try {
  withBoxUnlocked(() => { throw new Error("Pirates on the horizon! Abort!"); });
} catch (e) {
  console.log("Error raised: " + e.message); }
console.log(box.locked);
withBoxUnlocked(() => { console.log(box.content); });

class SomeError extends Error {}

foo = (garbage) => {
  if (garbage === "stuff"){ return "yep"; }
  throw new SomeError(garbage); }

fools = () => {
  let stuff;
  try {
    stuff = foo(prompt("Enter some stuff:"));
  } catch (e) {
    if (e instanceof SomeError) {
      console.log("Invalid Stuff:", e.message, "\nHave a nice day!");
    } else { throw e; }
  } finally {
    if (stuff === "yep"){
      console.log("👌 That's the stuff! 👌"); } } }

fools();

Use assert to correct your personal user error

class Group {
  constructor (){
    this.values = []; }
  val(iter){
    if ( iter > this.values.length ){ return undefined; }
    return this.values[iter]; }
  has(val){
    return (this.values.indexOf(val) !== -1); }
  add(val){
    if( !this.has(val) ){ this.values.push(val); } }
  delete(val){
    this.values = this.values.filter(n => n != val); }
}
Group.from = function(arr) {
  let temp = new Group;
  for(let i=0; i<arr.length; i++){
    temp.add(arr[i]); }
  return temp;
}
class GroupIterator {
  constructor(group) {
    this.loc = 0;
    this.group = group; }
  next() {
    if ( this.loc >= this.group.values.length ){
      return {done: true}; }
    let value = this.group.val(this.loc);
    this.loc++;
    return {value, done: false }; }
}
Group.prototype[Symbol.iterator] = function() {
  return new GroupIterator(this);
};

Does extends allow for multi-tiered inheritance? Ex:

class Array {...};
class Matrix extends Array {...};
class SuperMatrix extends Matrix {...};

as opposed to

const getSize => { return _size; }

JS map allows for non-string < keyType, valueType >

this => $scope

_private
_properties

public
properties

It would be much more elegant to have a node class, but for the sake of the exercise:

prepend = (value, list) => {
  return {value:value, rest:list};
}
arrayToList = arr => {
  head = null;
  for (let i = arr.length-1; i >= 0; i--){
    head = prepend(arr[i],head);
  }
  return head;
}
listToArray = list => {
  arr = []; head = list;
  while ( head !== null) {
    arr.push(head.value); head = head.rest;
  }
  return arr;
}
nth = (list,loc) => {
  if (head === null) { return null; }
  if (loc === 0) { return list.value; }
  return nth(list.rest, loc-1);
}

(() => {
    app.constant('constants', {
        SOMETHING: 'something',
        ELSE: 'else'
    });
})();

// constants.SOMETHING  ->  'something'

phenomenal

more complicated example of passing functions and the necessity of return statements:

function unless(test, then, other) {
  if (test) { return then(); }
  else { return other(); } }
function reduce(array, combine, start) {
  let current = start;
  for (let element of array) {
    console.log("current:",current,"element:",element);
    current = combine(current, element);
  } return current; }
console.log("final value:", reduce([1, 2, 3, 4],
  (a, b) => { return unless( b % 2 == 1,
    () => { return a + b; },
    () => { return a * b; } ) }, 0 ));

function defined control flow ( eg. main ) Also:

function unless(test, then, other) {
  if (!test) { then(); }
  else { other(); } }
repeat(3, n => { unless(n % 2 == 1,
    () => { console.log(n, "is even"); }, 
    () => { console.log(n, "is odd");  }) });

functions are simply variables

Function Purity

Elegantly Put

easily accessible surface code

School and Student have private classes on the Submitty Server. Figure out how they work to best understand how to write the homework

See Lecture 9

insert_student_into_school_preference U_of_M erin_jones john_smith

interesting the way she mentioned her examples as 'helpful for identifying and critiquing' before entering the main bodies.

Women who describe themselves as having PMS have been more likely to use coping mechanisms such as... religion... and less likely to use social support