diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e43b0f9 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.DS_Store diff --git a/examples/http-server.js b/examples/http-server.js new file mode 100644 index 0000000..f458a41 --- /dev/null +++ b/examples/http-server.js @@ -0,0 +1,54 @@ +var http = require('http'); + +var response = "" + +"" + +"Hello World!" + +"" + +"" + +"

We made it!

" + +"

The time is {time}!

" + + "

Node version: {node}
V8 version: {v8}

My Node.JS server

Hello World!

My Node.JS server

Hello {name}!

Node Version: {node}
V8 Version: {v8}
URL: {url}
Time: {time}

+bar + +``` + +Note we're printing out a ```Buffer``` object. That's because the ```input``` variable does not contain the string value of your input directly. + +It's worth noting that, at this point, the buffer exists completely outside of JavaScript memory. Interacting with this buffer will move data across the native to JavaScript boundary. For example, calling ```input.toString()``` will create a new JavaScript string containing the entire contents of the Buffer. An optional encoding can be specified as the first argument of the toString function (ie ```input.toString('utf8')```). + +Since we're working with relatively short commands lets go ahead and call ```input.toString()``` on the Buffer. Now starting up the shell and typing any value will result in the expected output ending with the new line character. + +The next step is to parse the input string. The commands in our simple shell will take the form: + + ```command [args...]``` + + A regex can separate the arguments from the command: ```/(\w+)(.*)/```. We can then parse the argument part of this by splitting each argument by white space. + +```js +stdin.on('data', function (input) { + var matches = input.toString().match(/(\w+)(.*)/); + var command = matches[1].toLowerCase(); + var args = matches[2].trim().split(/\s+/); +}); +``` + +Feel free to check out the result of this by logging out the value of ```command``` and ```args```. You may want to add a little more logic to make this resilient to malformed input. But we'll leave that excercise up to you. + + +## Our first command: pwd + +```pwd``` is a program to print out the current working directory. Let's implement this in our shell. + +```js +var stdin = process.openStdin(); + +var commands = { + 'pwd': function () { + console.log(process.cwd()); + } +}; + +stdin.on('data', function (input) { + var matches = input.toString().match(/(\w+)(.*)/); + var command = matches[1].toLowerCase(); + + commands[command](); +}); +``` + +To clarify what's happening above here's sample output of executing the regex at the Node REPL. The input is ```cmd_name arg1 arg2```. + +```JavaScript +> var input = "cmd_name arg1 arg2" +'cmd_name arg1 arg2' +> var matches = input.match(/(\w+)(.*)/) +> matches +[ 'cmd_name arg1 arg2', //matches[0] + 'cmd_name', //matches[1] + ' arg1 arg2', //matches[2] + index: 0, //matches[3] + input: 'cmd_name arg1 arg2'] //matches[4] + +``` +We are accessing ```matches[1]``` because it's the first group (groups are specified with the parenthesis). If you are unfamilar with Regular Expressions a good source to learn more is at [Regular-Expressions.info](http://www.regular-expressions.info/). + +Now, jump back to your terminal and give our shell a try! + +Start up the shell with Node: + +``` +node shell.js +``` + +Execute our one and only command: + +``` +pwd +/users/you/simple-shell/ +``` + +## A parameterized command: ls + +```ls [directory]```: prints the contents of a directory. If the directory argument is not specified it will print the contents of the current working directory. + +In order to process the arguments we need to add a little more parsing logic to the input. Since we split the command from the arguments with a regex we can now parse the second half of that string. Arguments are separated by white space so a simple regex split will give us what we need. In order to ignore unecessary white space let's trim the args string first. + +#### A quick side note: +The result of ```'some string'.split(/\s+/)``` is an array ```['some', 'string']```. + +This example could have been done with ```'some string'.split(' ')``` but would not account for other types of white space or multiple white spaces. + +For example: ```'some__string'.split('_')``` would result in ```['some', '', 'string']``` (underscores used because multiple consecutive white spaces were ignored by Markdown parser) + +```js +stdin.on('data', function (input) { + var matches = input.toString().match(/(\w+)(.*)/); + var command = matches[1].toLowerCase(); + var args = matches[2].trim().split(/\s+/); // split on white space + + commands[command](args); +}); +``` + +To implement ls add a new property to our object named 'ls' like this: + +```js +var fs = require('fs'); + +var commands = { + 'pwd': function () { + console.log(process.cwd()); + }, + 'ls': function (args) { // New property added here. Note the comma on the previous line + fs.readdir(args[0] || process.cwd(), function (err, entries) { + entries.forEach(function (e) { + console.log(e); + }); + }); + } +}; +``` + +Notice this part of the ls implementation: ```args[0] || process.cwd()``` + +Unlike many other languages, JavaScript doesn't care if you access an index out of bounds of an array. If an element does not exist at the index ```undefined``` will be returned. Using the ```x || y``` syntax will test the existence of ```x``` and if it doesn't exist will evaluate to ```y```. This is a common pattern for assigning a default value. + +Feel free to implement your favorite shell command as an exercise or follow along with the next part of this lab where we'll implement ```tail```. + +## Implementing tail + +```tail filename [N]```: prints the last N lines of a file. This requires us to locate all of the newlines in a file and trim down to last N number of lines to print. If N is not specified we'll print the last 10 lines. + +Implementing this will give you exposure to file streams, getting formation about a file, and useful Array functions. + +First, let's add the tail command to our commands object. After this point all examples will exclude the command object declaration. + +```js +var commands = { + 'pwd': function () { + console.log(process.cwd()); + }, + 'ls': function (args) { + // Implementation of ls here + }, + 'tail': function (args) { + // Implemtation of tail here. + }; +}; +``` + +First, pull in the ```fs``` module at the top of the file just after ```var stdin = process.openStdin();```. The fs module is the node core module for file system operations. + +``` +var fs = require('fs'); +``` + +Get the length of the file in bytes. + +To do this we'll need to stat the file path provided as the first argument. + +``` +// this is declared as a property of the commands object +'tail': function (args) { + var stats = fs.statSync(args[0]); + + console.log(stats); +} +``` + +The stat object looks like this: + +```js +{ dev: 16777219, + ino: 12794104, + mode: 33188, + nlink: 1, + uid: 501, + gid: 20, + rdev: 0, + size: 8066, + blksize: 4096, + blocks: 16, + atime: Sat Oct 13 2012 15:23:59 GMT-0500 (CDT), + mtime: Sat Oct 13 2012 13:40:02 GMT-0500 (CDT), + ctime: Sat Oct 13 2012 13:40:04 GMT-0500 (CDT) } +``` + +We're concerned with the size and blksize properties of the stat object for this exercise. + +With these properties we can create a read stream that starts at the beginning of the file and continues to the end. Each ```blksize``` bytes of the file will be provided to us through a callback. Here's the implementation: + +```js +'tail': function (args) { + var stats = fs.statSync(args[0]); + + var options = { + flags: 'r', + encoding: 'utf8', + mode: 0666, + bufferSize: 200, + start: 0, + end: stats.size + }; + + var fileStream = fs.createReadStream(args[0], options); + + fileStream.on('data', function (data) { + //This callback (anonymous function) will be + //executed for every blksize (bufferSize from options) + //bytes of the file. + }); +} +``` + +In our callback we'll examine each character in the buffer to see if it's a newline ```\n```. For each new line we'll track the byte offset for which it occurred in the file. + +We'll create an array to store the byte offset of each newline for the last N+1 lines. The +1 is so we can keep around an extra trailing line to start reading from. + +![Algorithm Explained](https://raw.github.com/nodekc/workshop/master/labs/images/last4lines.png "An illustration of the algorithm in use.") + +```js +var numLines = (args[1] || 10) + 1; +var newLineOffsets = new Array(numLines); +var offset = 0; // The offset in the file +var index = 0; // The array index for storing the next newline location + +fileStream.on('data', function (data) { + for (var i = 0; i < data.length; i++) { + if (data[i] === '\n') { + newLineOffsets[index] = offset + i; + index = ++index % numLines; + } + offset += data.length; + } +}); +``` + +Now, we need to add an event listener for the ```end``` event. In this callback we'll print the last N lines of the file. Add this just after the data callback. + +```js +fileStream.on('end', function () { + if (typeof newLineOffsets[index] === 'number') { + var position = newLineOffsets[index] + 1; + } + else { + var position = 0; + } + + var bytesToRead = stats.size - position; + + fs.open(args[0], 'r', function (err, fd) { + var buffer = new Buffer(bytesToRead); + fs.readSync(fd, buffer, 0, bytesToRead, position); + console.log(buffer.toString()) + }); +}); +``` + +If you're new to JavaScript you may be confused by the check to see if an element is a number. This ensures ```newLineOffsets[index]``` has been set to a number. If the value was never set it would be ```undefined```. Alternatively, this could have been: + +```js +typeof newLineOffsets[index] !== 'undefined' +``` + +Some examples of the ```typeof``` operator: + +* ```typeof 10``` => 'number' +* ```typeof 'nodelabs'``` => 'string' +* ```typeof true``` => 'boolean' +* ```typeof null``` => null + +**Important** + +Another important detail about this example is that the variable declaration happens within the braces of the conditional statement. In other languages ```position``` would not be available out of the scope of the conditional block. However, in JavaScript, ```position``` is available outside of the statement block because of how scoping is handled in JavaScript. In short, JavaScript scope is at the ```function``` level. If you want to read more search for *JavaScript variable hoisting* on Google. + + + diff --git a/labs/images/last4lines.png b/labs/images/last4lines.png new file mode 100644 index 0000000..700a8cd Binary files /dev/null and b/labs/images/last4lines.png differ diff --git a/labs/modules.md b/labs/modules.md new file mode 100644 index 0000000..e49e09d --- /dev/null +++ b/labs/modules.md @@ -0,0 +1,148 @@ +# Modules + +## Overview + +### Time + +30 minutes + +### Objectives + +- How to require node modules in a project. +- How to require a JSON file as a module +- How to require a core module +- How to require from the node_modules folder +- How to export methods in a module + +## How do modules work? + +In node, modules work by exporting methods or values. If this were visualized in JavaScript it might be similar to this: + +```javascript +var exports = {}; +(function() { + var a = 10; + exports.foo = a * 10; +})(); + +console.log(exports.a); // undefined +console.log(exports.foo); // 100 +``` + +Notice the ```(function () {/* module code here*/} )();```. This provides a new scope for the module to prevent pollution of the global object. + +If written into a node module, this would be written as: + +```javascript +var a = 10; +exports.foo = a * 10; +``` + +## require() a node module + +In this lab we'll ```require()``` a file into our project. + +First create a folder called ```/planets```. +Inside of ```/planets```, create a file called ```circle.js``` with the following contents: + +```javascript +var PI = Math.PI; + +exports.area = function (r) { + return PI * r * r; +}; + +exports.circumference = function (r) { + return 2 * PI * r; +}; +```` +The module ```circle.js``` has exported the functions ```area()``` and ```circumference()```. To export an object, add to the special exports object. Variables local to the module will be private. In this example the variable ```PI``` is private to ```circle.js```. + + +Next add another file to ```/planets``` called ```earth.js``` with the following contents: + +```javascript +var circle = require('./circle'); +var radius = 6378.1; +console.log( 'The area of the planet earth is ' + circle.area(radius) + ' km2'); +``` + +Now, run the app by typing ```node earth``` from within the ```planets``` directory. You should see the following: + +```shell +The area of the planet earth is 127800490.57763624 km2 +``` + +## require a JSON File + +A JSON file can be included in a project by doing a ```require('./data.json')```. This is because ```.json``` files are parsed as JSON text files. +Let's modify the previous example by storing the radius of all the planets in a JSON file. + +In the ```planets``` directory, create a file called ```planets.json``` with the following contents: + +```json +{ + "mercury": 2440, + "venus": 6051, + "earth": 6378, + "mars": 3397, + "jupiter": 71492, + "saturn": 60268, + "uranus": 25559, + "neptune": 24764 +} +``` + +View the ```planets.json``` file by firing up a node shell (```node``` without arguments) from within the ```/planets``` directory and typing the following: + +```shell +var planets = require('./planets.json'); +planets.neptune; +``` + +Try to output the radius of some other planets. + +Once you are comfortable with ```planets.json``` object, update the ```earth.js``` example by importing ```planets.json``` into ```earth.js```. + +```javascript +var planets = require('./planets.json'); +``` + +Finally, update ```earth.js``` to use the circumference stored in ```planets.json```. + + +## require a Core Module + +Node has several modules compiled into the binary. The core modules are defined in node's source in the ```lib/``` folder. +Core modules are always preferentially loaded if their identifier is passed to ```require()```. For instance, ```require('http')``` will always return the built in HTTP module, even if there is a file by that name. + +Let's use the core module assert to test ```circle.js```. In the ```planets/``` folder, create a file called ```test.js```. +In ```test.js```, require the ```assert``` module and ```circle.js``` to test the ```circle.area``` and ```circle.circumference``` methods. + +```javascript +var assert = require('assert'); +var circle = require('./circle'); +``` + +Next write a couple tests using the [documentation for assert](http://nodejs.org/api/assert.html) + +## requiring from the node_modules directory + +Modules can be installed using the node package manager, npm, to be included into your application. +For the next example, let's print out the planets in order of size. To do this, we'll include the ```underscore.js``` module. First we need to install underscore by executing the following command from within the ```planets/``` directory. + +```npm install underscore``` + +Now create a file called ```size.js``` and add the following: + +```javascript +var sortBy = require('underscore').sortBy, + keys = require('underscore').keys, + planets = require('./planets.json'); + +planets = sortBy(keys(planets), function(k) { return planets[k]; }) + +console.log(planets); +``` + +See [underscore.js documentation](http://underscorejs.org/#sortBy). diff --git a/lectures/Intro.md b/lectures/Intro.md new file mode 100644 index 0000000..f17c850 --- /dev/null +++ b/lectures/Intro.md @@ -0,0 +1,191 @@ +# What makes node.js possible. + +Node.js is a wrapper around Joyent's libuv and Google's V8 JavaScript engine. It provides a minimal approach to a framework for network communication. + +A major tenet of Node.js is that IO is performed asynchronously and there is no busy-waiting. The asynchronous IO calls is made possible through libuv and the already familar syntax of callbacks in JavaScript. + +In the simplest of terms, when an IO call is made a callback is required to invoke after completion. Libuv handles the scheduling and invocation of these callbacks through what is called the event loop. The event loop is the driving force behind why Node.js is considered asynchronous. Any time computation must wait for a slow network connection or hard disk a callback is placed in this event loop and execution is resumed in the JavaScript application. + +#Example of using node as a HTTP server + +```JavaScript +var http = require('http'); + +var server = http.createServer(function httpCallback(req, res) { + res.writeHead(200); + res.write("Hello world!"); + res.end() +}); + +server.listen(8000); +``` + +This simple example illustrates how node can be used to create an HTTP server that responds to all requests with "Hello world!" It is important to note that the call to ```server.listen(8000)``` essentially registers the ```httpCallback``` function with the libuv event loop. When an HTTP request is received, libuv and ultimately Node invokes the callback. + +``` +> curl http://127.0.0.1:8000 -i +HTTP/1.1 200 OK +Date: Fri, 28 Sep 2012 03:42:52 GMT +Connection: keep-alive +Transfer-Encoding: chunked +``` + +There are two important headers to consider. First, ```Connection: keep-alive``` allows for the connection to the server to be maintained between subsequent requests. This removes the overhead of the TCP negotion that would otherwise need to occur on every request. Second, ```Transfer-encoding: chunked``` allows for the Node server to respond with a variable length response. These two headers gives Node the ability to stream data in the response as it becomes ready. For example, waiting on the database to return a result set or reading a file off the disk. + +```JavaScript +var http = require('http'); + +function queryDatabase(callback) { + setTimeout(callback, 3000); //3 seconds +} + +var server = http.createServer(function (req, res) { + res.writeHead(200); + + queryDatabase(function () { + res.write("Hello World!"); + res.end(); + }); +}); + +server.listen(8000); +``` + +In this example, when a request is made to the server a long running database query is invoked. When this query finishes (in 3 seconds) a callback is invoked and the response to the client is finished. While the the first client is waiting for the operation to complete subsequent clients can still connect. We can test this behavior by opening multiple shells and making simultaneous requests. A timeout of three seconds was chosen to help visualize the non-blocking behavior. + +``` +> curl http://localhost:8000 +3000 milliseconds later... +Hello World! +``` + +Also worth noting is that ```res.end()``` is called inside the callback. This is why the connection is still open and can still receive "Hello world!" several seconds later. + +An example of a process that would be considered a gross misuse of node could be something like this: + +```JavaScript +var http = require('http'); + +var server = http.createServer(function (req, res) { + res.writeHead(200); + + while(true) { + } + + res.write("Hello World!"); + res.end(); + +}); + +server.listen(8000); +``` + +In this example Node is 100% busy serving the first request forever. Node does not operate with a threaded model. It is only ever doing one thing at a time in JavaScript. This is why performing computationally expensive operations is not a good use of Node. However, that's not to say that you cannot do CPU bound operations with Node. There are benchmarks showing the performance of JavaScript in V8 on the heels of equivelant C++ code. + +# When should you use Node? + +Any time you are creating an application that demands a high number of concurrent connections that do not need a lot of time on the CPU. Node is especially good at handling these concurrent connections because of its evented philosophy. + +Let's go back a few examples where our HTTP server is working hard for several seconds and then writes "Hello World!" to the response. Apache bench will allow us to simulate 100 concurrent connections and provide statistics about the response time. + +```ab -n 100 -c 100 http://127.0.0.1``` + +Note that the overall time for 100 concurrent connections to complete is roughly three seconds. Let's try it with 1000 concurrent connections. However, because of consumer OS limitations we must increase the number of ports that can be open on our machines. + +# Code to increase ulimit** + +```ab -n 1000 -c 1000 http://127.0.0.1``` + +# Lets dig into the Node process with the Node REPL + +When the Node process is run without arguments you are presented with a REPL (Read Evaluate Print Loop). The full power of V8 and Node is available through this interface. You can execute multi-line statements and inspect variables. This is similar to the JavaScript console that's available in many web browsers. + +Node has made an attempt to be consistent with many browser conventions. An example of this consistency is the implementation of setTimeout. This function wraps a native call in both browsers and Node to invoke a callback after a specifed number of milliseconds. This is not provided by V8 out of the box. As a matter of fact, V8 only provides the JavaScript execution engine. One similarity to the browser that Node provides is a global object that has information about the environment. In browsers this object is named 'window' and in Node it's named 'process'. These objects, whether in the browser or in Node, serve a similar purpose. + +``` +> node +> process.pid +1408 +> process.env +{ PATH: '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin', + SHELL: '/bin/zsh', + HOME: '/Users/joe', + USER: 'joe', + ... +} +``` + +Let's do something more complicated. Let's actually create our HTTP server through the REPL. It's as easy as copy and paste of a previous snippet to get it working. + +# A simple chat server + +A chat server requires a persistent connection instead of a request/response mechanism like HTTP. This requires the use of a different module called 'net' which is really TCP. TCP will allow us to keep connections i.e. sockets open and duplex data between the client and server. + +```JavaScript +var net = require('net'); + +var server = net.createServer(function (socket) { + socket.write('Hello World\n'); + socket.end(); +}); + +server.listen(8080); +``` + +Connect to this and you will be greeted with ```Hello World!``` and your connection will terminate immediately. In order to actually create a chat server we need to know who's connected and notify them of new messages. Obviously this also requires accepting messages and broadcasting them to connected clients. Let's try and do that. + +Our first modification is to keep a list of open connections and allow the connection to stay open. + +```JavaScript +var net = require('net'); + +var clients = []; + +var server = net.createServer(function (socket) { + clients.push(socket); + + socket.on('end', function () { + var index = clients.indexOf(socket); + clients.splice(index,1); + }); +}); + +server.listen(8080); +``` + +Now that we have an updating list of connected clients we can start accepting and broadcasting messages. Let's also be mindful that we do not want to echo messages we have sent back to ourselves. + +```JavaScript +var net = require('net'); + +var clients = []; + +var server = net.createServer(function (socket) { + clients.push(socket); + + socket.on('data', function (data) { + for (var i = 0; i < clients.length; i++) + { + var client = clients[i]; + + //Don't echo our messages + if (client === socket) + continue; + + client.write(data); + } + }); + + socket.on('end', function () { + var index = clients.indexOf(socket); + clients.splice(index,1); + }); +}); + +server.listen(8080); +``` + + + + + diff --git a/lectures/NPM.md b/lectures/NPM.md new file mode 100644 index 0000000..e52f50f --- /dev/null +++ b/lectures/NPM.md @@ -0,0 +1,79 @@ +# NPM (Node Package Manager) + +Node package manager is without a doubt one of the reasons Node.js has become so popular. NPM is not the only package manager that was created in response to Node.js but it's definitely the most widely used and is well maintained. Since members of the community have accepted it as the go to place to modules it has been pulled into Node core. + +Other languages and platforms provide similar package managers for example Ruby Gems is the go to place to find packages for Ruby. Examples of other package managers include: + +* C# - NuGet (http://nuget.org) with an awesome extension called "Chocolatey NuGet" for command line installation of common windows binaries. + +* Python - PyPm + +* Debian - aptitude + +NPM was created by Isaac Schlueter who is also the primary gate keeper for the main Node.js project. + +Package managers do the heavy lifting for many mundane tasks including installing, packaging, downloading, building, and most importantly resolving complex dependency trees. + +Anyone has the ability to create an NPM package. Some might think this is a flaw in the design because of potential name squatters. This problem, however, has not plagued the Node community at all. As a matter of fact, the community has been very responsible when it comes to name collisions. + +NPM provides statistics on its main website that can help those in search of a new package to have an idea of what they're getting. Simple statistics such as total downloads on a weekly basis and overall can answer the question of is this package still used by others. Number of dependents of a package is also an excellent indicator of how useful and stable a package is. + +![An example of a highly depended on module.](https://raw.github.com/nodekc/workshop/master/lectures/images/underscore_npm.png) + +NPM is managed through a command line interface using the command ```npm```. There's a ton of arguments that can be provided to perform different actions. The full list of arguments can be discovered by executing ```npm -l```. + +The most commonly used npm commands are: + +* install (to install a package in node_modules) +* init (to create the packages.json file) +* docs (to open the doc's page for a package) +* link (to link to a package locally during development) + +### npm install + +One of the sweetest things about NPM is that you can install from a variety of locations. Most commonly, however, packages are installed from the npmjs.org repository. + +## What is an NPM package? + +a) a folder containing a program described by a package.json file + +b) a gzipped tarball containing (a) + +c) a url that resolves to (b) + +d) a @ that is +published on the registry with (c) + +e) a @ that points to (d) + +f) a that has a "latest" tag satisfying (e) + +g) a git url that, when cloned, results in (a). + +### Package.json + +* Name +* Version +* Engines +* Scripts +* Author +* Main +* Directories + +### .npmignore + +Allows you to keep out unwanted directories or files from being published to NPM. If this file does not exist NPM will abide by .gitignore if it is present. The .npmignore file will completely override the .gitignore. + +## Publishing a package + +```npm adduser``` + +```npm publish``` + +Keep in mind that everything in your package directory will be published unless it's in the .gitignore or .npmignore files. + + + + + + diff --git a/lectures/images/joe_npm.png b/lectures/images/joe_npm.png new file mode 100644 index 0000000..5a0f5f8 Binary files /dev/null and b/lectures/images/joe_npm.png differ diff --git a/lectures/images/underscore_npm.png b/lectures/images/underscore_npm.png new file mode 100644 index 0000000..a1e8148 Binary files /dev/null and b/lectures/images/underscore_npm.png differ diff --git a/meetings/20120822.md b/meetings/20120822.md deleted file mode 100644 index a9069ec..0000000 --- a/meetings/20120822.md +++ /dev/null @@ -1,27 +0,0 @@ -Lunch meeting August 22nd: Dusty, Joe, Scott, Andrew - -# Timeline: -- Event date: between October 12th and 26th -- Public announcement: between September 14th and 28th -- Curriculum published: August 31st - -## Short-term timeline: -- Andrew: get working draft finished by Friday, August 24 -- Dusty: circulate draft to core contributors and revise -- Dusty: recirculate final working draft to core contributors by Wednesday, August 29 -- Andrew: publish final working draft to Meetup.com on Friday, August 31 - -- Joe: continue to investigate location scouting - -# Target audiences: -- Friday: Beginner programmer, Beginner JavaScript - - Beginning topics: installing node.js, intro to the command line, intro to javascript (strings, arrays) -- Saturday: Begintermediate JavaScript, Beginner Node.js - - Beginning topics: functions, events, callbacks - -# Curriculum choices: -- Not included: DOM, browsers, jQuery - -# Marketing choices: -- KC user groups -- Local colleges, high schools, middle schools \ No newline at end of file diff --git a/meetings/20120906.md b/meetings/20120906.md deleted file mode 100644 index 5ca30fd..0000000 --- a/meetings/20120906.md +++ /dev/null @@ -1,39 +0,0 @@ -Lunch meeting September 6th: Dusty, Joe, Scott, Andrew - -# Cirriculum -Mostly finalized. A few edits are required: -- Pull request #1 should be accepted. -- Dusty pointed out that because of how the schedule was planned, Friday and Saturday are both required for a beginner. If they show up on Saturday only, they'll be lost. We've decided to shift a lot of the content from Friday evening to Saturday, and have it mostly be centered around workstation setup and socialization. -- Joe came up with the idea of having "challenges" to partake in on Friday evening, to act as ice-breakers. Sponsors could provide prizes to these challenge winners. -- Time should be considered (including scheduling of breaks) with next revision. -- Dusty will be performing the required edits to the schedule. - -# Space -- Mike has request in for us to use Cerner's space -- Wes has offered Databasically's offices as a space, though the lack of breakout/common meeting space may be a downfall. -- Andrew will contact UMKC CS department about potentially providing a space. - -# Activities -- It would be nice to come up with some activities to have in our pockets (both for Friday evening's challenges and for breaks during the day on Saturday). -- Node summer camp would potentially be a good resource. - -# Handouts -- Speakers will be asked to develop handouts to go with their coverage of the curriculum. -- Handouts should contain examples/tutorials to augment content. -- Scott will create the handout for Friday evening (Getting Started). - -# Marketing -- To be determined are: an official name for the workshop, logos/graphics, posters to distribute to schools and around town, and a website (if needed). -- Andrew will be heading up the marketing of the workshop. -- The event will be created on EventBrite, and we'll ask somewhere around $10-15 for a ticket. The ticket price will be refunded on entering (making the event free to attend). - -# Sponsors -- Joe will track down potential sponsors (and follow up with them). -- Github has sent us a schwagbox. - -# TAs/helpers -- Dusty will be in charge of coordinating finding TAs to linger about the croud and answer questions. - -# Teachers -- Andrew and Joe expressed interest in teaching/speaking on the content of the curriculum. -- Scott mentioned that another group had hired teachers and taught them the content, and had those hired teachers actually do the teaching. \ No newline at end of file diff --git a/readme.md b/readme.md index 2b9943c..8020211 100644 --- a/readme.md +++ b/readme.md @@ -1,69 +1,3 @@ -# Beginner's Workshop for Node.js +# NodeLabs -``` -NOTE: This is a working draft. Please pull request changes. The outline is -particularly weak near the end. -``` - -## Friday: Workstation setup - -- Introduction to the group and the workshop -- Introduction to the command line on Windows, Mac OS X, or Linux -- Self guided tutorial to setup nodejs and intro to javascript as a calculator in the REPL, - running a .js file with node, and console.log() -- Hand out Saturday's schedule - -The self guided tutorial will be provided before the setup night for those who cannot -attend or want to get started early. - -## Saturday: Workshop -Bring a laptop, breakfast and lunch will be provided. - -### 0800: Workstation Setup Redux (with donuts!) -### 1000: Intro to Programming with Javascript -- Variables -- Native Types - - Number - - String - - Boolean -- Arrays -- Maps -- Flow control (if, else, and looping) - -### 1015: *Recitation:* FizzBuzz -### 1045: Activity TBD -### 1100: Functions in Javascript -- What is a function? -- Function expressions -- Function parameters -- Functions that *return* -- Functions that call functions - -###1115: *Recitation:* Reverse a numbers -- Write a function that reverses the digits in a number and returns it - -### 1145: Activity TBD -### 1200: Lunch -### 1300: Advanced Topics -- Functions as Function parameters -- Callbacks and EventEmitters -- Capturing keyboard input with stdin -- Reading and Writing files with `fs` package -- Reading a file from the web with `http` package - -### 1315: *Recitation:* Download a file from the web and save it to a file -### 1345: Activity TBD -### 1400: Breakout topics -- Website in express on Heroku/Nodejitsu/Engine Yard -- Advanced "Proper" Javascript - - Prototypal objects - - Variable scoping and closures - - Variable hoisting -- Software Engineering Fundamentals - - Testing - - Package management - - etc. - -### 1445: Activity TBD -### 1500: Back to work -### 1600: Done \ No newline at end of file +NodeLabs is an effort to provide opensource teaching materials for Node.js. \ No newline at end of file diff --git a/resources/pythonkc.txt b/resources/pythonkc.txt deleted file mode 100644 index 5c29efa..0000000 --- a/resources/pythonkc.txt +++ /dev/null @@ -1,48 +0,0 @@ -Hey, - -Yeah, it was a 2 day event which I think is important. We hosted it at -UMKC, they were very receptive and a great host, they might be able to help -you out as well. - -First night schedule went like this: - - - Intro about the group / workshop. Quick example of tutorial - - All members went through a self-guided tutorial to setup Python on - their system and walk though a set of exercises to get familiar with the - language. - - Once they completed that they just had to check off with an aide and - they were free to go. - -We followed this material on Friday night: -http://beginners-python-workshop.readthedocs.org/en/latest/index.html - -Saturday started off with a 2 hour Intro to Python presentation, the lunch -and then we all broke up into groups and did projects. We had a Django / -web dev project, twitter api project and a few others. - -Overall I think it went really well. We definitely got very technical but -at a beginners level. We had about 50 attendees and there were about 6 -helpers, and that was plenty. - -Good luck! Let me know if you need anything else. - -Andrew Schoen - -On Mon, Jul 30, 2012 at 8:29 PM, Andrew Dunkman wrote: - -> Hey Andrew! -> -> Thanks for your reply. I'm looking to do something similar to the -> PythonKC event. I couldn't make the event, but I've heard from a -> number of people how great the format was. -> -> I liked the idea of the Friday setup and Saturday workshop. -> -> How technical did you get? What was your schedule like? Did you stick -> to it, and how many people did you have helping? -> -> I heard that you modeled the workshop off another event=97is that true, -> and linky linky? :) -> -> Thanks for your help! -> Andrew \ No newline at end of file