| ## 211 S '05 Blog | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

## Important Messages from the Syndicate this site (XML) |

polynomial | derivative | scheme polynomial | scheme derivative |
---|---|---|---|

4 | 0 | `(list 4)` | `(list 0)` |

x + 3 | 1 | `(list 1 3)` | `(list 1)` |

x^{3} + 2x^{2} + 3x + 4 |
3x^{2} + 4x + 3 |
`(list 1 2 3 4)` |
`(list 3 4 3)` |

`der`

for handling the case
were we can have just a constant and one function called
`der2`

for handling the case that we have a term wih an
exponent of at least 1.
**Wednesday, March 16th, 2005 6:56:45pm**

Here are the various versions of random number lists we talked about today:randoms.ssA couple things to note:

- I used a helper function to test two of these functions. This is a simple use of functional abstraction. One can note that in order to test a function that is produce a list of
ndistinct numbers, there are two things to test: (1) that there arennumbers, (2) they are all distinct. So, we want to test this every time, but have one function to do it.- Secondly, I used
`local`

to define the accumulator function in the last example. This is an idiom. Essentially, the idiom is as follows: If you ever write an accumulator-style function`do-something`

as:you can usually write is as:(define (do-something a1 a2 ... an) (do-something-acc a1 a2 ... an <base-case>)) (define (do-something-acc a1 a2 ... an base-case) ... )Because, if you see, the only change is that instead of passing(define (do-something a1 a2 ... an) (local ((define (do-something-loop base-case)) ... ) (do-something-loop <base-case>)))`a1`

,`a2`

, ...,`an`

as arguments to`do-something-cc`

, you can make it a local, because`do-something-loop`

alreadysees`a1`

,`a2`

, ...,`an`

.

**Wednesday, March 16th, 2005 6:30:15pm**

Here is the code from today that we didn't get to:The first just finds path from two nodes in a graph; we discussed this in class previously. But this one has the small change that we determined

Graph paths: graph.ss Graph paths with an accumulator: graph-acc.ss Guessing: guess.ss ifthere is a path, but we're not concernedwhatit actually is. This raises a problem, as we'll see tomorrow, when there are loops in the graph; and this is solved in the second program. The last one simulates a guessing game. The idea is that`guess`

takes an oracle who tells whether the answer is`correct`

,`higher`

, or`lower`

than the current guess,`n`

. The method for guessing is that, at every step, we choose the next guess based on the previous guess and what the oracle tells us. If we guess a number that is higher than the correct answer and our last guess was higher, we'll choose a number right in the middle of the guessed number and lowest. If the last guess was lower, we'll choose a number right in the middle of the last number and the new guess. Therefor, weaccumulatethe last guess in`last`

. Using the method one can guess asecretnumber in a finite number of tries, depending on the range. Here, the range is 0 to 100. So, the number of guesses isO(f(r))for a ranger. One way of guess the functionf, is to run this program many times on many ranges. But in order to do this you need to determine how many guesses were made. So one task (exercise) is to right a new function based on`guess`

;; guess-tally: (Number -> Answer) Number -> Number ;; returns the number of guesses used is guessing p's number starting ;; with n (define (guess-tally p n) ... )

**Tuesday, March 15th, 2005 7:02:37am**

Here's the start of our`randoms`

program... try to finish it.And here is the code for the graph traversal we did in class:;; randoms: Number -> (listof Number) ;; returns a list of n random unique numbers (define (randoms n) (randoms-acc n ...)) ;; randoms-acc: Number (listof Number) -> (listof Number) ;; produces a list of n random numbers, and accumulates ;; the result in acc (define (randoms-acc n acc) (cond [(= n (length acc)) ...] [else (cons (random n) (randoms-acc (- n 1) ...))]))find-route.scm

**Monday, March 14th, 2005 11:25:17am**

Here (world-example.ss) is an example of using the`world.ss`

teachpack. You should first read the help documentation, then look at this example. We want to define a world that contains a rocket. World-passing style is a way of programming where that we use to represent the world. In particular we need a definition of the world. So we define the world as a union.The way this teachpack works is as follows: We will call;; Data Def: ;; World is one of ;; -- false ;; -- positive number ;; Interpretation: ;; -- false means the rocket hasn't been launched ;; -- number n means the rocket has been ;; launched and has reached height n`big-bang`

and tell it how big the world should be and how often to update it. In our example we have decided to update the world every`0.1`

seconds. So, every 0.1 seconds this teachpack will look for a function that we have passed to`on-tick-event`

, and this function should consume a World and produce an updated World. So, we need to define a function, we'll call ittock that consumes a World and returns a new world. For our world our new world will be a new world that contains a rocket that moved a little. We will use the special form:to define a function(update (world-draw w) produce (world-move w)))`tock`

. This function will update the world on every tick.Think of;; tock : World -> World ;; update the canvas and produce next world (define (tock w) (update (world-draw w) produce (world-move w)))`update`

asmagic. The expression passed to updated will be evaluated on every tick to update ourperceptionof the world; the expression to produce will be evaluated on every tick to produce a new world. One way to think of it isthat these`(update ... produce ...)`

are linked. Supposed we start by passing a world called`w0`

to`big-bang`

, then the calls to`tock`

are linked in the following way:This keeps going until we callThe world we see: (update w0 produce w0) | | output <-----* |----------* | | V V (update w1 produce w1) | | output <-----* |----------* | | V V (update w2 produce w2) | | output <-----* |----------* | | V V w3 w3 .... wn wn | | output <-----* |----------* | | V V (update wn produce wn)`end-of-time`

.

**Friday, March 11th, 2005 7:07:22am**

Here are the two examples from class yesterday:

Merge sort: mergesort.scm Fractal: fractal.scm Remeber, in

structual recursionwe recur over the shape of the input data. An example is the template for simple lists. Ingenerative recursionwe actually create new data on which to recur. Our examples yesterday were fractals and mergesort.To explain this in another way, let's look at the English statements for the two.

Structual:For example, consider a function to add 1 to every item in a list of numbers.In English this says "if the input list is empty, return empty; otherwise add 1 to the first item and recursively process the rest of the list."`;; add1*: (listof Number) -> (listof Number)`

`;; adds 1 to all in l`

`(define (add1* l)`

`(cond`

`[(empty? l) empty]`

`[else (cons (add1 (first l)) (add1* (rest l)))]))`

Note that I've colored coded the English statements and the code. Red corresponds to the termination case, and blue corresponds to the recursive case. In every recursive function you write your must note and state the termination condition. RepeatingGenerative:Take our merge sort example from class:In English this says "if the length of the input list if 1 or 0 return the list -- it's sorted; otherwise break the list in two and recur on those."`;; mergesort: (listof Number) -> (listof Number)`

`;; returns a sorted version of the input list`

`(define (mergesort lon)`

`(cond`

`[(<= (length lon) 1) lon]`

`[else (merge (mergesort (firsthalf lon))`

`(mergesort (secondhalf lon)))]))`

every recursive function you write your must note and state the termination condition!!!!As a style note, this termination case will usually show up as the first line of your cond statement, too.

**Thursday, March 10th, 2005 10:42:23am**

The examples from class today are here:list-functions-examples.scmIn particular we looked at three loops:`map`

,`filter`

, and`foldr`

. What's important to take from each of these is an understanding of what they do, and an understanding of when to use them. The following table shows what they actually do ... not the code.Here are some English meanings:

Loop Contract Meaning `map`

`(`

X->Y) (listofX) -> (listofY)`(map`

=f(listx_{0}x..._{1}x))_{n-1}

`(list (`

f x) (_{0}f x) ... (_{1}f x) )_{n-1}`filter`

`(`

X-> Boolean) (listofX) -> Boolean`(filter`

=f(listx_{0}x..._{1}x))_{n-1}

`(list (`

f x) (_{0}f x) ... (_{1}f x) )_{m}

where all`(`

aref x)_{0}`true`

.`foldr`

`(`

XY->Y)Y(listofX) ->Y`(foldr`

=fb(listx_{0}x..._{1}x))_{n-1}

`(f`

x... (f_{0}x(f_{1}x_{n-1}b)))Here are some concrete examples of using these functions to improve your programs. Note, I've omitted the examples and tests on this page for space reasons, but they are included in list-functions-examples.scm.

`(map`

: Applyfl)fto all items inl.`(filter`

: Keeps those items inpl)lfor whichpis`true`

.`(foldr`

: Cascadefbl)falong the items inl.

Example 1:We want to add 1 to all the items in a list of numbers. The naive implementation is:`add1*: (listof Number) -> (listof Number)`

We can identify`;;add1*: (listof Number) -> (listof Number)`

`;; adds 1 to all numbers in l`

`(define (add1* l)`

`(cond`

`[(empty? l) empty]`

`[else (cons (add1 (first l)) (add1* (rest l)))]))`

`add1`

as the function that we're applying to every item in the list, so we can use`map`

.`;; add1/map*: (listof Number) -> (listof Number)`

`;; adds 1 to all numbers in l`

`(define (add1*/map l)`

`(map add1 l))`

Examples 2:We want to keep all the negative numbers in a list. The naive implementation is:`negs: (listof Number) -> (listof Number)`

We can see we are using a predicate --`;; negs: (listof Number) -> (listof Number)`

`;; produces a list of on only the negative numbers in l`

`(define (negs l)`

`(cond`

`[(empty? l) empty]`

`[else (cond`

`[(negative? (first l)) (cons (first l) (negs (rest l)))]`

`[else (negs (rest l))])]))`

`negative?`

to decide whether to keep items -- and this sounds like we can use`filter`

.`;; negs/filter: (listof Number) -> (listof Number)`

`;; produces a list of on only the negative numbers in l`

`(define (negs/filter l)`

`(filter negative? l))`

Example 3:We want to sum all the items in a list of numbers. The naive implementation is:`sum: (listof Number) -> Number`

We notice, then, that we're cascading`;; sum: (listof Number) -> Number`

`;; sums the numbers is l`

`(define (sum l)`

`(cond`

`[(empty? l) 0]`

`[else (+ (first l) (sum (rest l)))]))`

`+`

along the items of the list and using`0`

as the base case. So, we realize this sounds like`foldr`

.Finally, we need to know when to use these loops. First, if you ever write the`;; sum/foldr: (listof Number) -> Number`

`;; sums the numbers is l`

`(define (sum/foldr l)`

`(foldr + 0 l))`

naiveimplementations above, you should use loops instead. Secondly, you need to identify when to use loops by purpose statements. These are sometrigger statementsin purpose statements that should lead you to the proper loop.

Loop Trigger purposes `map`

- Do something to all items in a list...
`filter`

- Remove all items such that...
- Keep all items such that...
`foldr`

- Combine the items of a list...

Notice

I have showed you the contracts, meaning, examples, and trigger statements for`map`

,`filter`

, and`foldr`

. You should go ahead and do the same for the rest of the loops. Only after using them can you really understand them!!!

**Thursday, March 10th, 2005 9:37:58am**

All the examples used in class yesterday are here.

The important topic that we have started talking about is

abstraction; in particular we got into loops on Monday. A reason we use abstraction is to have a single point of control for every idea. For example in our example in class we wrote one function that added 1 to every item in a list of numbers and one that subtracted one from every item in a list of numbers. These are the functions:First, let's abstract over the English version of these functions:;; add1-all: (listof Number) -> (listof Number) ;; adds 1 to all in l (define (add1-all l) (cond [(empty? l) empty] [else (cons (add1 (first l)) (add1-all (rest l)))])) ;; sub1-all: (listof Number) -> (listof Number) ;; subtracts 1 to all in l (define (sub1-all l) (cond [(empty? l) empty] [else (cons (sub1 (first l)) (sub1-all (rest l)))]))To do so we first identify the difference in the two: I have shown these differences in color.

`add1-all`

: add 1 to all items in the list `sub1-all`

: subtract 1 to all items in the list Now we make a more general (or abstract) version of these two functions. It's

`add1-all`

: add 1 to all items in the list `sub1-all`

: subtract 1 to all items in the list abstractbecause there's something missing -- i.e. what to do to every item in the list. We'll call thisdo-something.So, what we've done is get rid of everything that is the same in

`f1-all`

: do-somethingto all items in the list`add1-all`

and`sub1-all`

, and moved it to`f1-all`

. The parts that were same -- add 1 and subtract 1 -- are turned into a parameter --do-something. In order to define a function in terms of`f1-all`

we simply decide what to use fordo-something; for`add1-all`

we can use add 1 fordo-something; for`sub1-all`

we can use subtract 1 fordo-something. ConsiderSo, if we replace terms in

`add1-all`

: `f1-all`

wheredo-somethingis add 1`sub1-all`

: `f1-all`

wheredo-somethingis subtract 1`add1-all`

we have:This was in English. The correlation to Scheme is as follows: instead of English statements, we write functions; instead of defining one sentence in terms of another, we define a function by calling another function. So, instead of creating a new description for

`f1-all`

wheredo-somethingis add 1' do-somethingto all items in the list' wheredo-somethingis add 1add 1 to all items in the list `f1-al`

, we write a function:and pulled out the corresponding difference in;; f1-all: (Number -> Number) (listof Number) -> (listof Number) (define (f1-all do-something l) (cond [(empty? l) empty] [else (cons (do-something (first l)) (f1-all do-something (rest l)))]))`add1-all`

and`sub1-all`

as`do-something`

. Then, to define`add1-all`

in terms of`f1-all`

we decide to use that difference --`add1`

-- in place of`do-something`

, and this means we call`f1-all`

passing in`add1`

for`do-something`

. We do similarly for`sub1-all`

:But, we can use a(define (add1-all l) (f1-all add1 l)) (define (sub1-all l) (f1-all sub1 l))loopcalled`map`

that is even more abstract than`f1-all`

. This loop has the following contract:That is,;; map: (X -> Y) (listof X) -> (listof Y)`map`

takes a function that consumes data of some typeXand produces data of some typeY(noteXcould be the same asY, but need not), a list ofX, and produces a list ofY. It calls this function on every item in the input list and the outcome of that call becomes an item in the output list. So, we can haveXandYbe`Number`

, and define`add1-all`

and`sub1-all`

as:Consider a call of(define (add1-all l) (map add1 l)) (define (sub1-all l) (map sub1 l))`add1-all`

on the list`(list 1 2 3)`

that produces the list`(list 2 3 4)`

. Visually this looks like this:Another way of thinking about calling

`(add1-all`

`(list`

1 2 3 ) ) | | | | `add1`

| `add1`

| `add1`

| | | V V V `(list`

2 3 4 ) `map`

with a function`f`

and list`(list`

i_{0}i_{1}... i_{n-1}`)`

,Another loop is`(map f`

`(list`

i_{0}i_{1}... i_{n-1}`)`

`)`

=`(list`

`(f`

i_{0}`)`

`(f`

i_{1}`)`

...`(f`

i_{n-1}`)`

`)`

`build-list`

that consumes a Numbernand a functionfwith contract`(Number ->`

X`)`

. It produces a list withnitems, where the n^{th}item is the result of callingfonn. That is:Here is an example:`(build-list`

nf`)`

=`(list`

`(`

f`0)`

`(`

f`1)`

...`(`

fn-1`)`

`)`

;; id: X -> X ;; identity function (define (id x) x) ;; simple-list: Number produce a list of numbers from 0 to n-1 (define (simple-list n) (build-list n id)) ;; Examples (equal? (simple-list 0) empty) (equal? (simple-list 10) (list 0 1 2 3 4 5 6 7 8 9))

**Tuesday, March 8th, 2005 10:49:21pm**

Since we're a bit behind and school may be closed tomorrow Assignment 8 will be due Thursday 3/9.

**Sunday, March 6th, 2005 11:14:28am**

I hope you all had a nice break. I have made assignment 8 due this Wednesday, 3/9, because we will cover loops on Monday. In addition, I have changed the description so that the data structure you're using is called`Auto`

, not`Car`

. If you have started the assignment you will have noticed that defining a structure called`car`

doesn't work. This is because`car`

and`cdr`

are another terms for`first`

and`rest`

, respectively; but just not as intuitive.

**Wednesday, February 23rd, 2005 6:18:50pm**

A student (and a good one) challenged that this program, for additional program #1, works:;; find-sublist: LoS LoS -> Number ;; retuns the number of times pat occurs in big (define (find-sublist big pat) (cond [(or (empty? pat) (empty? big)) 0] [(boolean=? (compare big pat) false) (find-sublist (rest big) pat)] [else (+ 1 (find-sublist (rest big) pat))])) ;; compare: LoS LoS -> Boolean ;; returns true if the first series of big is found in pat (define (compare big pat) (cond [(empty? pat) true] [(symbol=? (first big) (first pat)) (compare (rest big) (rest pat))] [else false]))I say it doesn't... can you find the error in it. Hint, here are some tests that fail.

**Monday, February 21st, 2005 7:53:12am**

Michael will hold office hours this Tuesday, 2/22, from 2:30-4:30pm. Sarah will hold office hours on Wednesday, 2/23 from 11am-1pm. Here is the material from last Monday and Thursday's class:

**Monday, February 21st, 2005 7:53:05am**

John Patota expressed an interest in using the newsgroup as a means of communication in this class, and I back him up 100 percent. This is a valuable tool to help solve problems and find answers. Kindly, John has written up instructions for using the news group under thunderbird.

Here they are:Now go into SSH Secure Shell Client (Windows)**:

- Click on File->New->Account
- Select the Newsgroup account option
- Enter in your name and e-mail address
- The Newsgroup Server is localhost
- Enter any name you want as the account name
Lastly, go back to thunderbird:

- Start up the client
- Select the
Edit menu, and choosesettings- Under the
Profile Settingsmenu, choosetunneling, then selectoutgoing- Click
Add- Pick a display name (e.g., "news")
- Select TCP as your protocol
- Enter 1119 as the port number
- Make sure the
Allow local connections onlyis checked- Enter
news.ccs.neu.eduas the destination host- Enter port 119 as the destination port
- Click Enter
I wrote that assuming users also were forwarding an outgoing connection with smtp.ccs.neu.edu on port 25 as well. Information on this can be found on the System's howto page.

- right click on the newsgroups icon
- select "subscribe"
- navigate to ccs.courses.csu211
- click on the check mark to the right and press ok

**Friday, February 18th, 2005 11:38:50am**

Homework 7 will be due on Wednesday 2/23, not Monday. I'd suggest you get it done earlier than this, though. Again, the second part of this course is often harder for many students; so don't get behind.

**Monday, February 14th, 2005 10:48:12am**

The exam results are here. These are histograms of the individual problems, the final score, and one composite of them all. Overall the class did quite well with a median score of about 46/50. Here is an additional breakdown. The problems are "#1" through "#6" and the total score isTotal:I will hand the hard copies back in class today (2/14). If you did well, congratulations! But,

Result #1 #2 #3 #4 #5 #6 Total max8 10 10 12 10 9 58 min2 0 0 1 0 0 14 median8 10 7 10 7 5 45.5 mean7.07 9.07 6.30 9.61 6.76 4.73 43.57 stddev1.52 2.15 3.13 2.26 2.84 2.96 11.06 mode8 10 10 11 6 4 48 do notlet up. The rest of this course tends to give students more a problem than the first half. But, if you did do well congratulations!

**Thursday, February 10th, 2005 6:27:53pm**

No lab Friday (2/11), enjoy it, go skiing!

**Thursday, February 10th, 2005 2:32:55pm**

The exam location has changed to 13 Snell Library. Same time: 6:30-9:30pm.

**Wednesday, February 9th, 2005 6:37:23pm**

Michael will hold office hours from 12-2pm tomorrow (2/10) in the regular place. I, also, have my office hours, so please come with questions or just come if you feel lost. Remember, analyze the data, make a template of how one would process that data, make some examples, then start to write functions.

Good luck tomorrow in the exam!

**Tuesday, February 8th, 2005 8:56:38am**

Sarah will hold office hours Wednesday (Feb 9) from 10am-12pm in the usual place.

**Saturday, February 5th, 2005 9:11:47am**

Remember the first midterm will be this Thursday (2/10) from 6:30-9:30pm in Richards 200. It will cover all the material from class, the book, labs, and homework thusfar. It will be open book and open notes.

**Wednesday, February 2nd, 2005 6:17:17pm**

Here are the examples from today's class: Remember,alwaysask the four questions when constructing a template:For example, if we have the data definition for a list of numbers:

- How many cond lines?
- What are the questions for each line?
- What are the selectors for each line?
- Any arrows (i.e. self-reference)?
We ask the first question:;; A ListOfNumber is one of ;; -- empty ;; -- (cons Number ListOfNumber)and construct the outline of the template:How many cond lines?Then ask question 2:`;; f: ListOfNumber -> ??`

`(define (f los)`

`(cond`

`[ ... ]`

`[ ... ] ))`

and determine the questions to ask:What are the questions for each line?The ask question 3:`;; f: ListOfNumber -> ??`

`(define (f los)`

`(cond`

`[(empty? los) ... ]`

`[(cons? los) ... ] ))`

and determine how to take apart our input:What are the selectors for each line?Finally, ask question 4:`;; f: ListOfNumber -> ??`

`(define (f los)`

`(cond`

`[(empty? los) ... ]`

`[(cons? los) ... (first los) ... ... (rest los)... ] ))`

and the answer isAny arrows (i.e. self-reference)?YES, from`ListOfNumber`

in line 2. For every arrow, we get recursion:`;; f: ListOfNumber -> ??`

`(define (f los)`

`(cond`

`[(empty? los) ... ]`

`[(cons? los) ... (first los) ... ... (f (rest los))... ] ))`

**Monday, January 31st, 2005 6:00:33pm**

Here is the material from class today: Also, as I stated in class today, if you receive a 0 on a quiz, that week's homework (turned in the Monday before that lab) will be deducted 50%; if you get a 1 nothing will happen; if you miss lab you will receive a 0 on that homework.

**Thursday, January 27th, 2005 6:31:51pm**

Examples from today's class are here: Remeber the main example in class today converting images from color to black and white (or greyscale). Our goal was to write a program called`image->bw`

that behaved in the following manner:`(image->bw`

`) ; should produce`

Knowledge about images or colors was

notimportant. The important concept that we learned today, was that when we process lists of structures our data definition changes; and when our data definition changes our programs for processing that data changes; so we need to change our templates.The purpose of a template is to provide you with a systematic way of processing data. When you are processing a list there are certain things that remain constant over all types of lists. Consider the data definitions for a list of numbers and a list of strings; paying close attention to the difference between the two:

So, we see that the only difference between the two is what type the`;; A ListofNumber if either`

`;; -- empty`

`;; -- (cons Number ListOfNumber)`

`;; A ListofString if either`

`;; -- empty`

`;; -- (cons String ListOfString)`

`first`

of the list is. So, let's write the templates for these data definitions:Not much is different between the two, except what we do to the`;; ListOfNumber -> ??`

`(define (f l)`

`(cond`

`[(empty? l) ...]`

`[(cons? l) ... (number-function (first l)) ... (f (rest l)) ...]))`

`;; ListOfString -> ??`

`(define (f l)`

`(cond`

`[(empty? l) ...]`

`[(cons? l) ... (string-function (first l)) ... (f (rest l)) ...]))`

`first`

of the lists... but we expected that, because the change in the template is directly from the difference in the data definition. But what if we consider a list of`Posn`

? Let's first consider the data definitions:Then, we can write the template for lists of`;; A Posn is a (make-posn x y)`

`;; where x and y are Numbers`

`;; A ListofPosn if either`

`;; -- empty`

`;; -- (cons Posn ListOfPosn)`

`Posn`

s.This is close, but we actually can take our data definition for lists of`;; ListOfPosn -> ??`

`(define (f l)`

`(cond`

`[(empty? l) ...]`

`[(cons? l) ... (posn-function (first l)) ... (f (rest l)) ...]))`

`Posn`

s a bit further, because we know what makes up a`Posn`

; so we know how to take it apart.So, since our data definition changes our template`;; A ListofPosn if either`

`;; -- empty`

`;; -- (cons (make-posn x y) ListOfPosn)`

`;; where x and y are Numbers`

must reflect this change!!!`;; ListOfPosn -> ??`

`(define (f l)`

`(cond`

`[(empty? l) ...]`

`[(cons? l) ... ((posn-x (first l)) ... (posn-x (first l))`

... (f (rest l)) ...]))

So, the main point is our programs always

FOLLOW THE DATA!!!

**Tuesday, January 25th, 2005 6:13:43am**

Sarah with hold an extra office hour today from 2-3pm.

**Sunday, January 23rd, 2005 10:16:22pm**

Because of the school closing on Monday 1/24, homework #3 will be due at 4:30pm on Tuesday 1/25.

**Thursday, January 20th, 2005 5:59:33pm**

Here are a couple examples from today's class:

**Thursday, January 20th, 2005 4:13:51pm**

Additional Problem 1 of homework 3 had a typo in it that asked you to modify`Calendar`

so it would keep track of months. Of course, it already kept track of months, and you should modify it to keep track of days. This has been changed on the assignment.

**Thursday, January 20th, 2005 10:15:55am**

Per Sean's request, here is the example from class yesterday.

**Thursday, January 20th, 2005 9:24:48am**

The first assignment included a 30-word description of any problems you encounted. This is now optional and should be a maximum of 30 words. The purpose of this is twofold: First, I want to hear feedback about problems you're having and questions you have that you may not want to voice in class or office hours. Secondly, the 30-word maximum is to get you to write clearly and "to the point"; this will be very valuable in anything you go on to do.

**Monday, January 17th, 2005 11:24:59am**

You all should have picked up your graded homework #1's in lab. If you didn't, please get them from me. The average was about 16.1 out of 26. Nine of you did not submit homework; if you are one of these people and I have you email address you will have received a message from me asking me to explain why this was the case?

Reminder: Homework #2 is due 1/18 by 4:30, and your contract is due by class time on 1/19. See the general page for information about your contract.

**Thursday, January 13th, 2005 3:07:02pm**

You will all sign up for lab partners tomorrow. At this time youmust-- at least -- get your partner's name, email, and phone number. Since the second homework is due Tuesday and your will not partner up until Friday, the first homework may be done in partners or indidivually. Either, please indicate clearly who worked on any homework handed in.

**Wednesday, January 12th, 2005 6:27:01pm**

Here is John Patota's explanation of the RSS thingy for the blog.Thanks for the note, John.A few days ago I asked what that RSS link was on the top of the blog. As it turns out, RSS is an easy way to distribute news. Whenever Jeff posts something new on the blog, it gets sent directly to your e-mail messaging program (like Mozilla's thunderbird)

If you use thunderbird, setting this feature up is really easy.

- create a new RSS News and Blogs account. Put any name you wish for the label of the account. The default "News and Blogs" works fine.
- You'll see a new icon which looks like the world come up on the left hand side of the screen, in the Folders panel. In the main window, click on "Manage Subscriptions" which will bring up a new box.
- Add a new account. Remember to input "http://www.ccs.neu.edu/home/jpalm/211-s05/index.xml" and click OK.
And your done

This new RSS thing is becoming very popular. Tons of websites are sharing to come out with things like this. An example would be our very own Northeastern News. Their RSS feed is "http://www.nu-news.com/articles.rss"

**Tuesday, January 11th, 2005 2:53:00pm**

Many of you forgot to write the 30-word description of problems you encountered on your homework, and those people lost points. You will lose points for this every time for forgetting this part. Also, many of you turned in loose papers, and this is unacceptable. You must staple or paper-clip your homework.

My office hours will be on Thursday from 2:30-4:30pm. Please come by if you have any questions or if you're running into problems on the homework.

**Monday, January 10th, 2005 6:34:29am**

If you have not done so, please read the 'Earning a Grade' section of the General Information page. It states the requirements for earning a greade in this course. I will mention this at today's lecture.

Also, our tutor for the term will be Sarah House. She can be reached at

`house`

`@`

`ccs`

`.`

`neu`

`.`

`edu`

. Sarah's primary responsibility will be grading, but will also hold office hours and pop in lab from time to time.

**Friday, January 7th, 2005 5:14:00pm**

Everyone please welcome Michael Everett (everett.m @ neu . edu), he will be the TA for the Spring. Michael will run the labs -- starting this Friday 1/14 -- and hold office hours; these office hours will be announced next week.

**Thursday, January 6th, 2005 6:39:16pm**

The first assignment is due

this Monday 1/10 by 4:30, and all assignments will be due at this time. I will post my office hours shortly. In the mean time send any questions to me at:`jpalm`

`@`

`ccs`

`.`

`neu`

`.`

`edu`

.Labs will begin next Friday 1/14. You will learn about the format of the labs and decide partnerships. You will complete all labs and homework (after assignmen #1) in partnerships. This is how the real world works, so this is how this class will run. If you cannot make this first lab contact Jeff.

And, remember to brings your name signs next week!

**Friday, December 31st, 2004 10:50:30am**

Added the gallery.

**Thursday, December 30th, 2004 10:08:28am**

Welcome to the 211 Blog site for Spring '05. The staff will post important messages here, concerning lectures, projects, presentations, and so on. Make a habit of reading the blog on a daily basis.

**Thursday, December 30th, 2004 8:53:35am**

Added RSS feed.

last updated on Thursday, April 21st, 2005 10:04:02am | generated with PLT Scheme -- (Source) |