Soma-notes - User contributions [en]

WebFund 2013F Lecture 19

2013-11-25T23:53:48Z

Sarahmathieson:

==Notes==
==Assignment 4 remarks
* Shouldn’t need to use prototypes at all in assignment
# Before insert, do a lookup
## If there, you have the document and edit that
# Search for a special room called “start”
## Start is not a room, it’s a room pointer
## Can put description of a room in there
## Could have everything linked to the start room
### Have all rooms exit to start
### Title won’t be start
# JavaScript string replace
## Don’t use a for-loop
### There are nice string manipulation routines in JavaScript
# TA’s will be using their own custom database to test code
# Look up how to do file uploads
## Might do this in tutorial
## Don’t have to do string checking, just have to check objects to make sure all fields are there and they aren’t undefined
## Do all the exits refer to a room that actually exists?
### Not super important to do
## Each room has name, title, description exits, has a start room
### Can say valid
# Have to validate the data structure
## Have to make sure you don’t import garbage
# Don’t have to do this with AJAX
==non assignment stuff==
** To get style points, probably going to have to do something nice
*** Probably don’t want to have to press submit a million times
* Always time costs when you distribute a system
* How’s it going to fail?
** Anything from a database is expensive
* Want a static webserver for front end
** Incoming requests first go through here, if it can handle it, it will hand it off and respond
** If it can’t, it will send it back
* Gets don’t change server state, posts do
* Gets can be cached
* CDN
** Content Distribution Network
** Some combination between static servers and caching
* Reading is never a problem
* Searches are easy
* Writes are what slow you down
** Cannot be automatically replicated
** Changed the state of part of your database, essentially your data structure
** This is what limits database scalability
* Fred Brooks

WebFund 2013F Lecture 19

2013-11-25T23:52:32Z

Sarahmathieson: Created page with "==Notes== ==Assignment 4 remarks * Shouldn’t need to use prototypes at all in assignment # Before insert, do a lookup ** If there, you have the document and edit that # Sear..."

==Notes==
==Assignment 4 remarks
* Shouldn’t need to use prototypes at all in assignment
# Before insert, do a lookup
** If there, you have the document and edit that
# Search for a special room called “start”
** Start is not a room, it’s a room pointer
** Can put description of a room in there
** Could have everything linked to the start room
*** Have all rooms exit to start
*** Title won’t be start
# JavaScript string replace
** Don’t use a for-loop
*** There are nice string manipulation routines in JavaScript
# TA’s will be using their own custom database to test code
# Look up how to do file uploads
** Might do this in tutorial
** Don’t have to do string checking, just have to check objects to make sure all fields are there and they aren’t undefined
** Do all the exits refer to a room that actually exists?
*** Not super important to do
** Each room has name, title, description exits, has a start room
*** Can say valid
# Have to validate the data structure
** Have to make sure you don’t import garbage
# Don’t have to do this with AJAX
** To get style points, probably going to have to do something nice
*** Probably don’t want to have to press submit a million times
* Always time costs when you distribute a system
* How’s it going to fail?
** Anything from a database is expensive
* Want a static webserver for front end
** Incoming requests first go through here, if it can handle it, it will hand it off and respond
** If it can’t, it will send it back
* Gets don’t change server state, posts do
* Gets can be cached
* CDN
** Content Distribution Network
** Some combination between static servers and caching
* Reading is never a problem
* Searches are easy
* Writes are what slow you down
** Cannot be automatically replicated
** Changed the state of part of your database, essentially your data structure
** This is what limits database scalability
* Fred Brooks

WebFund 2013F Lecture 18

2013-11-25T23:45:46Z

Sarahmathieson:

The audio from the lecture given on November 20, 2013 is [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec18-20Nov2013.m4a here].

==Notes==

* When you do app.get the things in the parameters are callback functions
* [[File:Nov20a.png]]
* [[File:Nov20b.png]]
* Server has to enforce data and integrity
** Why for database?
*** THEY HAVE TO HOLD. No matter what they can never be inconsistent

File:Nov20b.png

2013-11-25T23:44:07Z

Sarahmathieson:

File:Nov20a.png

2013-11-25T23:43:41Z

Sarahmathieson:

WebFund 2013F Lecture 16

2013-11-25T23:38:37Z

Sarahmathieson:

The audio from the lecture given on November 13, 2013 is [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec16-13Nov2013.m4a here].

==Notes==
* Control flow graph
** graph representation of program structure
** you should know how things move in your program
*** graph is weird for web applications
**** no main => event driven
**** distributed
***** control flow goes between browser and one or more servers
**** RPC (RemoteProcedureCall)
***** sometimes when making a call? Actually making a call on something on the network
***** RPC's have fundamental security problems
***** always call by value (pass number along)
**** SOAP
***** effort to do RPC over the web
***** Problems?
****** Based on XML
******* very verbose
******* SOAP protocols based on XML are VERY verbose
**** REST
***** GET, POST, etc
* Databases
** don't want to store everything just in a text file
*** multiple files is a pain
** associative arrays are easier to get access to
** concurrency
*** I want to change data structures all over the place
**** allow for concurrent updates without corrupting entire thing
** durability
*** can change values incrementally
** We will be using MongoDB
*** “document store”
**** it's like you are storing a collection of word documents
**** allows to to incrementally update parts of the document without corrupting everything
**** transactions
***** making changes to multiple durable data structures
****** changes are always consistent
******* all should happen or none should happen
******* atomic commits
***** documents are basically JSON objects

WebFund 2013F Lecture 15

2013-11-11T23:42:06Z

Sarahmathieson: Created page with "==Notes== ===Assignment 3 Tips=== * Question 6 : Every time the user score changes, you can update the high score ** Cheating! It doesn’t have to be constantly updated in ..."

==Notes==

===Assignment 3 Tips===
* Question 6 : Every time the user score changes, you can update the high score
** Cheating! It doesn’t have to be constantly updated in the background
** Or could use long poling
*** Do ajax type call on the client
*** On the server you would wait, set up a callback for when the high score changes
* Question 4:
** var container = $(‘#container’);
*** returns a jQuery object
** //for the canvas:
*** c = $(‘canvas’)[0];
** Anil will post something online about the problem errorsount.play();
** Need to use jQuery equivalent for the container.offsetLeft etc in function init()

===Going through tutorial 9===
* In package.json there is a new line:
** "validator": "*"
*** used for sanitizing user input
*** req.session.player = sanitize(player).escape();
**** sanitize sooner rather than later
**** we only used this in the start function because this is the only user input that was taken
* Want to send something back to the client?
** You can just use ‘send’ in node
* Complexity has been moved to the client code
* On the browser:
** If you want privacy, the only way you have it is doing it within functions!
*** In public/javascripts/adventure.js
**** Anonymous function is defined
**** Prevents you from polluting the global file scope
** In public/javascripts/adventure.js
*** $.getJSON("/getContents", function(room)
**** Get JSON object from server
**** getContents is a function in routes/index.js
**** this will return a page with an enoded JSON object
***** jQuery will happily convert this
** var exits;
*** doesn’t do anything
$('.exits').remove();
room.roomExits.forEach(function(theExit) {
$('#exitList').append(
'<button type="button" id="' + theExit +
'" class="btn btn-default exits">'
+ theExit + '</button>');
$('#'+theExit).on('click', function() {
$.post("/doAction", {action: "move",
room: theExit});
getRoom();
});
});
*** Get rid of all of the exits
*** Add button
*** Add even handler
*** When someone clicks on the mouse, it creates another post
*** The value of the exit is coming from the argument to the function
*** Array objects in JavaScript have a standard object called foreach
** Every webpage defines its own JavaScript scope
*** Script is similar to include in C
** Implications of scripts
*** You don’t know what code you’re incorporating
*** It changes from minute to minute
*** It runs in the same executions context of your code
*** You have to deal with the DOM – it is global and everyone potentially has access to it
**** What’s to say that code isn’t changing your code
**** There are some things you can do, but it’s not easy

WebFund 2013F Lecture 7

2013-11-10T16:31:39Z

Sarahmathieson: /* Note */

Audio from the lecture given on September 30, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec07-30Sep2013.m4a here].

==Note==

September 30

* cookies
** text document
** saves info on what you were doing on site
* stateless
** HTTPS
** SSH
* what can server do to keep track of client?
** Cookies!
*** Something the server sets
*** sent along later
** Encode information in the url itself
*** that will say what this session identifier is
* Server can't trust anything the client sends
* webrequests are stateless
* How to make sure the user doesn't mess with your cookies
** have to be encoded
*** cookies should look like garbage
***if you can hand edit the cookie you are doing something really dumb
* state is being passed around in url
* remote procedure calls
** a program calling another and passing stuff around
** ie. like buttons on webpages
* [[File:sept30.jpg]]
* block
** running (on a 4 core processor you could have 4 processes running simultaneously)
** ready (waiting for a free processor)
** waiting on I/O (blocked until something has happened)
* synchonous I/O
** read (b)
** what happens here?
*** Program went to sleep and is woken up
*** could be doing other things here instead of giving up the CPU!
*** Not efficient to switch between processes
** scanf(b)
*** only makes sense after read is completed
* in node when you do any I/O code it returns immediately
** asynchronous
** callbacks solve asynchronous promblem
*** read(s, b, callback)
**** do the read request, and when it's done, here is the code to run encoded in this callback
* node acts like a dispatcher
** constantly routing data
* classic callback in node
** listen line
*** has a port number + callback function

WebFund 2013F Lecture 14

2013-11-10T16:27:48Z

Sarahmathieson:

Audio from the lecture given on November 6, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec14-06Nov2013.m4a here].

==Notes==
November 6, 2013

* Sandbox
** [[File:nov6a.png]]
*** Untrusted Applet restrictions
**** Only portion of screen
**** No file i/o
**** Same origin policy for the network
***** Download a program from the internet? It can’t just access anything on the internet
***** Can only talk to the server from which it was downloaded
*** If an applet is signed? You can trust it.
*** Digital signature/certificate
**** Certificates are containers for digital signatures
**** (ps,pp)
**** S = ps(h(d)), pp(s)=h(d)
***** You know it could only come from someone who had ps
****** Not only do I have the hash? I have the hash that was produced by someone who has this secret key which corresponds to this public key
****** How do you know you have the right public key? Get it signed
****** Certificates are public keys plus meta data along with signatures of the public key
**** [[File:nov6b.png]]
**** Sender encrypts with private key
*** No digital signatures on javascript code you download into your browser
**** Have to live with restrictions
**** Sandbox is taking over your whole computer

File:Nov6b.png

2013-11-10T16:23:39Z

Sarahmathieson:

File:Nov6a.png

2013-11-10T16:23:25Z

Sarahmathieson:

WebFund 2013F Midterm Review

2013-11-10T16:17:10Z

Sarahmathieson:

Audio from the lecture given on October 16, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec11-16Oct2013.m4a here].

Note that Assignment 2 is now due on October 17 (Thursday) by 4:05 PM.

==Readings==

You may want to read (or re-read) these chapters to get a bit more depth on the topics covered in class.

* ''JavaScript, The Good Parts:'' Chapters 3 (Objects), 4 (Functions), and 6 (Arrays)
* ''Learning Node:'' Chapters 2 (REPL), 4 (Modules), 6 (Routing and Connect), 7 (Express), 8 (Jade only)

Note Express exposes much of the functionality of Connect.

==Notes==

October 16
* Have until Thursday at 4pm to finish assignment 2
* Midterm
** read JavaScript : ch3, ch4, ch6
** read Learning Node: ch2, ch4, ch6
* puzzle.js
** global scopt – Y
** file scope - p, f, repl
** y and q and available at prompt,
*** repl has it's own scope – that's why q is available at prompt
*** .context is dereferencing repl.start

WebFund 2013F Lecture 10

2013-11-10T16:15:27Z

Sarahmathieson:

The audio from the lecture given on October 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec10-09Oct2013.m4a here].

==Notes==
October 9

* for question 3
http.createServer(app).listen(app.get('port')....
app.set('port', process.env.PORT||3000);
** in process.env.port you change the port
** execve
*** program binary //path to program you want to run
*** command -line arguments
*** environment variables //variable name, variable value
**** normally inherited from parent processes
** can set port in the shell by saying ie:
*** export PORT = 5000
** env puts out the variables the current process has
** can set up multiple node processes by changing the port in the shell and using the same code
* q 6 add a count to the properties of the object
[[END OF PREMIDTERM STUFF]]
* in public we basically have a static web server
* why minified?
** Client side javascript is minified
** removes all unnecessary characters
*** ie comments
* bootstrap needs jquery
** so we're including bootstrap AND jquery
* jquery is foundational thing of all modern web apps
* $. or ($)
** jquery object
* jquery is client side only
** javascript queying of the DOM

WebFund 2013F Lecture 7

2013-11-08T21:59:58Z

Sarahmathieson:

Audio from the lecture given on September 30, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec07-30Sep2013.m4a here].

==Note==

September 30

* cookies
** text document
** saves info on what you were doing on site
* stateless
** HTTPS
** SSH
* what can server do to keep track of client?
** Cookies!
*** Something the server sets
*** sent along later
** Encode information in the url itself
*** that will say what this session identifier is
* Server can't trust anything the client sends
* webrequests are stateless
* How to make sure the user doesn't mess with your cookies
** have to be encoded
*** cookies should look like garbage
***if you can hand edit the cookie you are doing something really dumb
* state is being passed around in url
* remote procedure calls
** a program calling another and passing stuff around
** ie. like buttons on webpages
* [[File:http://homeostasis.scs.carleton.ca/wiki/index.php/File:Sept30.jpg]]
* block
** running (on a 4 core processor you could have 4 processes running simultaneously)
** ready (waiting for a free processor)
** waiting on I/O (blocked until something has happened)
* synchonous I/O
** read (b)
** what happens here?
*** Program went to sleep and is woken up
*** could be doing other things here instead of giving up the CPU!
*** Not efficient to switch between processes
** scanf(b)
*** only makes sense after read is completed
* in node when you do any I/O code it returns immediately
** asynchronous
** callbacks solve asynchronous promblem
*** read(s, b, callback)
**** do the read request, and when it's done, here is the code to run encoded in this callback
* node acts like a dispatcher
** constantly routing data
* classic callback in node
** listen line
*** has a port number + callback function

File:Sept30.jpg

2013-11-08T21:54:49Z

Sarahmathieson:

WebFund 2013F Lecture 6

2013-11-08T21:45:55Z

Sarahmathieson: /* Topics */

Audio for the lecture given on September 25, 2013 is available [https://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec06-25Sep2013.m4a here].

==Readings==

* Chapter 4, "Functions", in ''Learning Node''

==Topics==

* function invocation patterns
** method
** function
** constructor
** apply
* scoping, environments

==Notes==

September 25

* functions
* this
** object you are currently accessing inside of an object
* 4 method invocation patterns
** (only difference is how this is used)
** method
*** obj.method(args);
**** this === obj;
** function
*** m = obj.method;
**** m(args);
** constructor
*** x = new m(args);
**** this === { }; //empty object
**** // don't say new? it becomes the global object
*** 2 ways to keep yourself out of trouble using "new"
**** any function / constructor that is supposed to use "new" start it with a capital letter
***** don't use new at all
****** start with an empty object and return it
** apply
x = m.apply( this value, arg array);
x = f(1) //x is a reference to h because we return it
//pointer into h along with the context in which it was called
var f = function (a) {
var g = function (b) {
return b+3
}
var h = function (c){
return(a+g(c);
}
return h;
}
a = private
b= private, argument scoped to function
c = private, argument scoped to function
f = global
g = private, g&h can see each other
h = private, g&h can see each other
x = global, reference to h but cannot access g because have not returned it's value
* if you say obj.h =x will give you access to g, then f becomes a function
* assignment
** no constructor because no use of "new"
app.configure(function(){
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
app.use(express.bodyParser());
app.use(express.methodOverride());
app.use(app.router);
app.use(express.static(__dirname + '/public'));
});
* using method
* app is being cast as 'views'... and set
* this in this case has been assigned to app
* node never blocks
* symbol can refer to a function

WebFund 2013F Lecture 5

2013-11-08T21:38:35Z

Sarahmathieson: /* Topics */

Audio from the lecture given on September 23, 2013 is [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec05-23Sep2013.m4a here].

==Readings==

* Chapter 4 in ''Learning Node'' (Modules)

==Topics==

* node modules
* function <tt>arguments</tt> array
* return values

==Notes==

September 23

var express = require('express')
, routes = require('./routes');
* in the case of node, var express makes a local variable
** this means it is global (but private to) a file
** ./routes - a directory in the directory you are in
** express is somewhere else
*** express is in the node module directory
*** "look for the code in the express directories in one of the node modules"
* npm install populates the node modules directory
* exports object is a special object
exports.add = function(req, res){
res.render('add', { title: 'Person added',
name: req.body.name,
country: req.body.country,
date: req.body.birthday,
email: req.body.email});

* come from text fields on page input from user
* res.render
** rendering in graphics -rendering a ball, wire frame, textures, lighting etc.
** this is what creates the page
** default renderer is jade
*** provides a template for entire page that is then filled in with parameters
h1 Info Added
p Name: #{name}
p Country: #{country}
p Date: #{date}
p Email: #{email}
* describes what your page will look like
* !!! is used in jade
** stuff needed for standard syntax
** doctype html
* jade-lang.com/reference
* html, jade, css, javascript
* html
** markup language with tags using angle brackets <> </>
* indentation in jade is very important
** kind of like python
** language for generating html pages
* div are divisions
** essentially specifying a block
* any time you call a function in javascript there is a thing called arguments
** it is bound to an area with all the arguments
** function takes a variable amount of arguments
* push
** in java script an array is already a stack
** can push an element on the top
** works for the first element in the array
* pop
** works for the last element of the array
* arrays are variably sized objects
** can be accessed in different throughout
** ordered
** similar to object
** loosely typed

WebFund 2013F Lecture 4

2013-11-08T21:33:23Z

Sarahmathieson: /* Topics */

Audio from the lecture given on September 18, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec04-18Sep2013.m4a here]

==Readings==

* Chapters 3 (Objects) and 4 (Functions), ''JavaScript: The Good Parts''

==Topics==

* Array versus dot notation for objects
* scoping
** <tt>var</tt> declarations
* <tt>prototype</tt> and delegation
* empty objects
* object literals
* reflection
**<tt>typeof</tt>
** <tt>hasOwnProperty</tt>
* <tt>for</tt> and object properties
* <tt>delete</tt>
* global abatement
* functions as objects
* function literals

==notes==

September 18

* empty object
** foo={ };
* delegation : waiting for another object to do your work
** similar to inheritance in java
* delegation of objects happens in the prototype property
* every object has a default prototype
* everything delegates to object
** similar to inherits but there are no classes and no hierarchy
* object reflection
** look inside an object and see what's there
* for loops in javascript
for(p in foo){

}
** similar to a for each loop in java
** will iterate through all the properties in foo, no fixed order
** [[DO NOT DO THIS]]
** follows prototype and looks at the properties in the entire prototype chain
* typeof(foo.x) can tell you if x is
** number
** string
** object
* foo.hasOwnProperty('x') returns true or false
* for loops that don't care about the prototype chain
** create an array that has the properties you want and iterate through them
* vector array uses [] instead of {}
** ie. [5, hello, etc];
** use an array because they're ordered!
* foo.x is equivalent to foo["x"]
** objects are like associative arrays where you index by letters/strings

==FUNCTIONS==

* functions are an object
* scope!
** scoping rules : visibility of identifiers
*** variables
*** constants
*** functions
*** objects etc

===2 ways for scoping===

* dynamic
** symbols you can access and the meaning of them depends on what code has been run before hand
** x=7;
** x=3;
** x is what part came first
** global variables are inheritently global scoped
* lexical/textual
*** variables it can see depends on what is around it
*** idea of local variables
* javascript has a very important global score
* create a namespace to keep global script from getting too big
** but doesn't exist in a standardized form
* global abatement - minimize what you write in the global scope
* local variable, say var in front of it
* no block scope in javascript, function scope is not block scope
f = function(a){
return function(b)[
return a+b;
}
}; // data encapsulation
g = t(5); g(7); returns 12

WebFund 2013F Lecture 3

2013-11-08T21:24:47Z

Sarahmathieson:

Audio from the lecture given on September 16, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec03-16Sep2013.m4a here].

Readings:
* Chapters 1-3, ''JavaScript: The Good Parts''
* Chapters 1-2, ''Learning Node''

Topics covered:
* REPL (read-eval-print loop)
* JavaScript quirks
** Numbers are all floats
** ambiguous comment characters
** === equality
** undeclared variables have global scope
* JavaScript objects and variables
** loose typing
** scoping
** prototypes versus classes
** JSON notation

==notes==
September 16
* history of JS
* REPL
* quirks
** equality
** numbers
** comments
** globals
* browser vs serverJS
* symbols and assignment
* object

[[history of JS]]
* nothing to do with java
* created over the course of a few weeks (~10 days) to script webpages
** got into Netscape 2 in the late 90's
* not great, but got there at the right time, standardized
** premature, rough draft, mistakes were made
* some amazing ideas, some so good that let you get around the rest of the issues
* don't think about C, don't think about Java, think about LISP
** 2nd oldest language (goes back to late 1950's
** modern variants - scheme (cleaner version)
** LISP = LiSTProcessing
*** at the time, it was all about symbol programming

==REPL==
* Model
* Read
* Eval

basically evaluating all the time
* Print
** output of print can almost always be sent to read
** that means the data structure is in a format that can be read in
* Loop
* can do things incrementally, iteratively
* no compilation
** no compile time errors, only ~runtime errors
* loosely typed - generally not statically typed
** refers to the nature of the symbols you manipulate
** in C x=5;
*** is storing the value of 5 somewhere in memory
*** int, double, short, char... etc
* in javascript x=5
*** not ambiguous
*** y=x+5 won't give you an error until code is executed
* can write smaller programs that are more expressive
* some people hate javascript because of the browser
** DOM - Document Object Model
*** ugly, painful, inconsistent
* quirks
** write code to work on one browser, doesn't work properly on another
** less pain than before, but still a factor
** mobile stuff still being standardized
==quirk #1==
f = function(a,b) {
x=7;
}
* wouldn't see this in something like C,
* in JavaScript it becomes a global variable
* have to specify that it is a local variable
* all symbols are seen globally by everyone else because there is no linker
* don't pollute global namespace

==quirk #2==
* comments can only be //, can't block comment
==quirk #3==
* equality operator is ===, for comparisons
* == does a shallow comparison
==quirk #4==
* no integer type
* can't do integer division without explicit truncates etc
* have to be conscious that you are using floats when doing numeric computations
var x = {
color "red";
model "unknown";
};
//this is an object, object notation
* property and value
* no classes
x.make = "?"
var x = {
make"?";
color "red";
model "unknown";
prototype : car;
crash.function(velocity); // method
};
* x.prototype is the same as car
* x.prototype.make="Tesla";
** there is inheritance -- but it's weird
*** prototype-based inheritance
**** prototype : car;
*** x.model

* symbols can refer to any value, have no type
* browser vs server JS

WebFund 2013F Lecture 2

2013-11-08T21:13:44Z

Sarahmathieson:

Video walkthroughs that were shown in lecture and class and associated notes are posted [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/email-crypto/ here].

This lecture should give an overview of the encryption of email, and what it means to apply a digital signature to an email message. There will be video demonstrations of how to setup both S/MIME and PGP on an Ubuntu machine with Thunderbird.

The RFCs that relate to the topics presented will include:

RFC 821 : SMTP - simple mail transfer protocol

RFC 5652: CMS

RFC 2440: OpenPGP Message Format

RFC 3851: S/MIME 3.1

Links for setting up your software:

[https://help.ubuntu.com/community/GnuPrivacyGuardHowto Ubuntu GPG HowTo]

[http://www.gnupg.org/ GPG Main Website]

[https://support.mozillamessaging.com/en-US/kb/digitally-signing-and-encrypting-messages Mozilla Thunderbird Enigmail Info]

September 11
* most email is sent in plaintext
* SMTP is a store and forward protocol
* Hops may use point-to-point encryption
* Analog days: passing notes in class
* End to End Encryption
** PGP
*** pretty good privacy
*** encrypt or digitally sign mail
** S/MIME
** attacker doesn't know at which point to get to message
** wouldn't know how to unencrypt unless they had key
*point to point encryption: SSL/TLS
** can attack at many points through mail transfer
*asymmetric - a public key and a private key
** two keys, one is public one is private
*** can use either to encrypt message

[[Sending message
]]|Hi Bob!| -> hash function (MD5) ->|0110110|->Encrypt ->Signature
signature Private Key

[[Receiving Message]]
|Hi Bob!|-sh>md5sum msg.txt->|0110110|->Decrypt -> Signature value
Signature
Public Key

* if anything changed in transit, it would change hash function value and would let you know that the message integrity has failed
* by not encrypting we cannot ensure integrity of communications
* trace route a couple of your packets
* IETF = ISO
** RFC
*** SMTP
*** CMS
** OpenPGP
*** GPG -> free license
*** PGP (Pretty good privacy)

WebFund 2013F Lecture 1

2013-11-08T21:09:07Z

Sarahmathieson: /* Notes */

Audio from the lecture given on September 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec01-09Sep2013.m4a here].

==Notes==

September 9
Node

Web
Browser <-talks to-> Server

==how?==
* http <-- Stream of text or data byte stream from tcp and puts syntax on it
* tcp <-- turns packets into continuous stream, controls sending, reordering etc
* ip <--packet based
* ethernet/wifi/...

==now: ==
Browser <-talks to-> Server
program talking to program
(embedded in
html document
that was loaded)

most of data on internet is encoded in http or smtp
code that runs inside of browser is known as sandboxed
* everything you care about is in the sandbox

google tracks and monetizes you
* ''you'' are the product

[[bandwidth:]] how much can I get at once?
[[latency:]] when I make a request, how long does it take for me to get the first bit

gmail has all kinds of code built in to predict what you want and predicts which emails you're going to want to read
constantly modelling your behaviour to work well

==Server== (not actually going to learn any of these languages)
* PHP
* servlets
* apache
* rails

==node.js is javascript==
* Why? runs pretty fast
* chromes v8 javascript engine and stuck on the server

==on browser access the DOM==
* browser manipulates the DOM
* no DOM on server

learning javascript running on server first THEN on the browser
Server puts together an HTML document that it sends to the browser and then using this they talk to each other
* can't trust the browser.
* browser keeps no secrets
* any data sent to server has to be appropriately validated

Database is persistent data structure for servers
* relational database

callbacks -> asynchronous I/O
* here is some code, do this when ...

processes
threads :
* start new thread
* heavier weight than you want
* not efficient

WebFund 2013F Lecture 1

2013-11-08T21:03:11Z

Sarahmathieson: /* Notes */

Audio from the lecture given on September 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec01-09Sep2013.m4a here].

==Notes==

September 9
Node

Web
Browser <-talks to-> Server

[[how?]]
http <-- Stream of text or data byte stream from tcp and puts syntax on it
tcp <-- turns packets into continuous stream, controls sending, reordering etc
ip <--packet based
ethernet/wifi/...

[[now:]]
Browser <-talks to-> Server
program talking to program
(embedded in
html document
that was loaded)

most of data on internet is encoded in http or smtp
code that runs inside of browser is known as sandboxed
everything you care about is in the sandbox

google tracks and monetizes you
''you'' are the product

[[bandwidth:]] how much can I get at once?
[[latency:]] when I make a request, how long does it take for me to get the first bit

gmail has all kinds of code built in to predict what you want and predicts which emails you're going to want to read
constantly modelling your behaviour to work well

Server (not actually going to learn any of these languages)
PHP
servlets
apache
rails

[[node.js is javascript]]
Why? runs pretty fast
chromes v8 javascript engine and stuck on the server
[[on browser access the DOM]]
browser manipulates the DOM
no DOM on server

learning javascript running on server first THEN on the browser
Server puts together an HTML document that it sends to the browser and then using this they talk to each other
- can't trust the browser.
- browser keeps no secrets
- any data sent to server has to be appropriately validated

Database is persistent data structure for servers
-relational database

callbacks -> asynchronous I/O
- here is some code, do this when ...

processes
threads :
-start new thread
- heavier weight than you want
- not efficient

WebFund 2013F Lecture 1

2013-11-08T20:59:48Z

Sarahmathieson: /* Notes */

Audio from the lecture given on September 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec01-09Sep2013.m4a here].

==Notes==

September 9
Node

Web
Browser <-talks to-> Server

[[how?]]
http <-- Stream of text or data byte stream from tcp and puts syntax on it
tcp <-- turns packets into continuous stream, controls sending, reordering etc
ip <--packet based
ethernet/wifi/...

[[now:]]<nowiki>Insert non-formatted text here
Browser <-talks to-> Server
program talking to program
(embedded in
html document
that was loaded)

most of data on internet is encoded in http or smtp
code that runs inside of browser is known as sandboxed
everything you care about is in the sandbox

google tracks and monetizes you
''you'' are the product

bandwidth: how much can I get at once?
latency: when I make a request, how long does it take for me to get the first bit

gmail has all kinds of code built in to predict what you want and predicts which emails you're going to want to read
constantly modelling your behaviour to work well

Server
PHP
servlets <-- not actually going to learn any of these languages
apache
rails

node.js is javascript
Why? runs pretty fast
chromes v8 javascript engine and stuck on the server
on browser access the DOM
browser manipulates the DOM
no DOM on server

learning javascript running on server first THEN on the browser
Server puts together an HTML document that it sends to the browser and then using this they talk to each other
can't trust the browser.
browser keeps no secrets
any data sent to server has to be appropriately validated

Database is persistent data structure for servers
relational database

callbacks -> asynchronous I/O
here is some code, do this when ...
processes
threads : start new thread
heavier weight than you want
not efficient

</nowiki>

WebFund 2013F Lecture 1

2013-11-08T20:57:06Z

Sarahmathieson: /* Notes */

Audio from the lecture given on September 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec01-09Sep2013.m4a here].

==Notes==

September 9
Node

Web
Browser <-talks to-> Server
http <-- Stream of text or data byte stream from tcp and puts syntax on it
tcp <-- turns packets into continuous stream, controls sending, reordering etc
ip <--packet based
ethernet/wifi/...

now:
Browser <-talks to-> Server
program talking to program
(embedded in
html document
that was loaded)

most of data on internet is encoded in http or smtp
code that runs inside of browser is known as sandboxed
everything you care about is in the sandbox

google tracks and monetizes you
''you'' are the product

bandwidth: how much can I get at once?
latency: when I make a request, how long does it take for me to get the first bit

gmail has all kinds of code built in to predict what you want and predicts which emails you're going to want to read
constantly modelling your behaviour to work well

Server
PHP
servlets <-- not actually going to learn any of these languages
apache
rails

node.js is javascript
Why? runs pretty fast
chromes v8 javascript engine and stuck on the server
on browser access the DOM
browser manipulates the DOM
no DOM on server

learning javascript running on server first THEN on the browser
Server puts together an HTML document that it sends to the browser and then using this they talk to each other
can't trust the browser.
browser keeps no secrets
any data sent to server has to be appropriately validated

Database is persistent data structure for servers
relational database

callbacks -> asynchronous I/O
here is some code, do this when ...
processes
threads : start new thread
heavier weight than you want
not efficient

WebFund 2013F Lecture 1

2013-11-08T20:53:26Z

Sarahmathieson: /* Notes */

Audio from the lecture given on September 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec01-09Sep2013.m4a here].

==Notes==

September 9
Node

Web
Browser <-talks to-> Server
http <-- Stream of text or data byte stream from tcp and puts syntax on it
tcp <-- turns packets into continuous stream, controls sending, reordering etc
ip <--packet based
ethernet/wifi/...

now
Browser <-talks to-> Server
program talking to program
(embedded in
html document
that was loaded)

most of data on internet is encoded in http or smtp
code that runs inside of browser is known as sandboxed
everything you care about is in the sandbox

google tracks and monetizes you
you are the product

bandwidth: how much can I get at once
latency: when I make a request, how long does it take for me to get the first bit

gmail has all kinds of code built in to predict what you want and predicts which emails you're going to want to read
constantly modelling your behaviour to work well

Server
PHP
servlets <-- not actually going to learn any of these
apache
rails

node.js is a javascript
Why? runs pretty darn fast
chromes v8 javascript engine and stuck on the server
on browser access the DOM
browser manipulates the DOM
no DOM on server

learning javascript running on server first THEN on the browser
Server puts together an HTML document that it sends to the browser and then using this they talk to each other
can't trust the browser.
browser keeps no secrets
any data sent to server has to be appropriately validated

Database is persistent data structure for servers
relational database

callbacks -> asynchronous I/O
here is some code, do this when ...
processes
threads : start new thread
heavier weight than you want
not efficient

WebFund 2013F Lecture 1

2013-11-08T20:52:20Z

Sarahmathieson: /* Notes */

Audio from the lecture given on September 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec01-09Sep2013.m4a here].

==Notes==

September 9
Node

Web
Browser <-talks to-> Server
http <-- Stream of text or data byte stream from tcp and puts syntax on it
tcp <-- turns packets into continuous stream, controls sending, reordering etc
ip <--packet based
ethernet/wifi/...

now
Browser <-talks to-> Server
program talking to program
(embedded in
html document
that was loaded)

most of data on internet is encoded in http or smtp
code that runs inside of browser is known as sandboxed
everything you care about is in the sandbox

google tracks and monetizes you
you are the product

bandwidth: how much can I get at once
latency: when I make a request, how long does it take for me to get the first bit

gmail has all kinds of code built in to predict what you want and predicts which emails you're going to want to read
constantly modelling your behaviour to work well

Server
PHP
servlets <-- not actually going to learn any of these
apache
rails

node.js is a javascript
Why? runs pretty darn fast
chromes v8 javascript engine and stuck on the server
on browser access the DOM
browser manipulates the DOM
no DOM on server

learning javascript running on server first THEN on the browser
Server puts together an HTML document that it sends to the browser and then using this they talk to each other
can't trust the browser.
browser keeps no secrets
any data sent to server has to be appropriately validated

Database is persistent data structure for servers
relational database

callbacks -> asynchronous I/O
here is some code, do this when ...
processes
threads : start new thread
heavier weight than you want
not efficient

WebFund 2013F Lecture 1

2013-11-08T17:08:50Z

Sarahmathieson:

Audio from the lecture given on September 9, 2013 is available [http://homeostasis.scs.carleton.ca/~soma/webfund-2013f/lectures/comp2406-2013f-lec01-09Sep2013.m4a here].

==Notes==
put notes here