Recent Changes - Search:
ECG Home

GitHub

People

Publications

Calendar

Projects

Fall 2017

Older Courses

Spring 2017

Fall 2016

Spring 2016

Fall 2015

Spring 2015

Fall 2014

Spring 2014

Fall 2013

Spring 2013

Fall 2012

Spring 2012

Fall 2011

Spring 2011

Fall 2010

Spring 2010

Fall 2009

Spring 2009

Fall 2008

Spring 2008

Fall 2007

HOWTOs

edit SideBar

Comp4spr14

Comp4spr14.Comp4spr14 History

Hide minor edits - Show changes to output

April 12, 2014, at 12:18 PM by 192.168.0.12 -
April 12, 2014, at 12:14 PM by 192.168.0.12 -
Changed lines 1-109 from:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[https://groups.google.com/forum/#!forum/91-204-202-s14 | Discussion Group]]

! Markov Model of Natural Language

In this assignment, we analyze an input text for transitions between ''k-grams'' (a fixed number of characters) and the following letter.

Then we produce a probabilistic model of the text: given a particular ''k-gram'' series of letters, what letters follow at what probabilities?

Then we use the model to generate nonsense text that's surprisingly reasonable.

See the full assignment at the Princeton site: http://www.cs.princeton.edu/courses/archive/fall13/cos126/assignments/markov.html

!! Implementation

Begin by implementing the following class:

[@
class MarkovModel
----------------------------------------------------------------------------------------
// Note: all of the below constructors/methods should be public.

      MarkovModel(string text, int k)// create a Markov model of order k from given text
                                      // Assume that text has length at least k.

  int order()                        // order k of Markov model

  int freq(string kgram)            // number of occurrences of kgram in text
                                      // (throw an exception if kgram is not of length k)

  int freq(string kgram, char c)    // number of times that character c follows kgram
                                      // if order=0, return num of times char c appears
                                      // (throw an exception if kgram is not of length k)


  char randk(string kgram)            // random character following given kgram
                                      // (Throw an exception if kgram is not of length k.
                                      //  Throw an exception if no such kgram.)

string gen(string kgram, int T)      // generate a string of length T characters
                                      // by simulating a trajectory through the corresponding
                                      // Markov chain.  The first k characters of the newly
                                      // generated string should be the argument kgram.
                                      // Throw an exception if kgram is not of length k.
                                      // Assume that T is at least k.

          <<                        // overload the stream insertion operator and display
                                      // the internal state of the Markov Model. Print out
                                      // the order, the alphabet, and the frequencies of
                                      // the k-grams and k+1-grams.
@]

!! Details

* This is the same as the Princeton spec except that the class method @@rand@@ has been renamed @@randk@@.

* Here is a header file to get you started: Attach:MarkovModel.hpp.

* Make sure you throw @@std::runtime_error@@'s in the methods per the spec. Review how to do this in [[PS5a]].

* Test your implementation against the following test file: Attach:mmtest.cpp.

* Consider the behavior of a 0-order model. This model will generate new characters with a distribution proportional to the ratio they appear in the input text. This model is context-free; it does not use an input kgram (representing the current state of the model) when generating a new character. As such:

** The @@freq(string kgram)@@ method takes an empty string as its input kgram (length of kgram must equal the order of the model).

** This method call should produce as a result the length of the original input text (given in the constructor).

** The @@freq(string kgram, char c)@@ also will take a null string as input. It should produce as output the number of times the character @@c@@ appears in the original input text.

* Per discussion in class, consider using a C++ map (http://www.cplusplus.com/reference/map/map/) store frequency counts of each kgram and ``k+1''-gram as it's encountered when you traverse the string in the constructor.

* Make sure to wrap around the end of the string during traversal, as described in the Princeton assignment.

* At construction time, it is highly recommended to build up a string that represents the active alphabet and store it as a private class member variable.

->This will be useful when implementing the @@randk@@ method, so that you can produce all of the ''k+1''-grams that may follow the provided kgram, test for the frequency of each ''k+1''-gram, and then produce output characters with proportional frequencies.

->Make sure to use the map's @@find@@ or @@count@@ methods to test for the existence of hypothetical ''k+1'' grams. If you use the map's @@[]@@ operator or @@at@@ accessor, you'll create an entry in the map for the ''k+1''-gram&#151;even if it's never encountered in the input. This would be quite wasteful of space. So use @@find@@ or @@count@@ to test for its existence without creating it.

* See Willie Boag's suggestion in the discussion group for how to generate output characters that follow the probability distribution that's discovered in the input: [[https://groups.google.com/forum/#!topic/91-204-202-s14/16yuB54d5Fw]]. You don't have to do it this way; it's just a suggestion.

* ''Overload stream insertion operator to display internal state of Markov model:'' See these sample instructions for [[how to do the overload->http://www.learncpp.com/cpp-tutorial/93-overloading-the-io-operators/]]. You should print out all of the ''k''-gram and ''k+1''-gram frequencies, the order of the model, and its alphabet. Here are sample instructions for [[how to build an iterator over the map->http://stackoverflow.com/questions/4844886/how-to-loop-through-a-c-map]] of ''k''-gram and ''k+1''-gram keys.

* Create a Makefile or include short, direct instructions for how to build your project.

* Fill out the [[Attach:ps6-readme.txt]].

!! Submit

Submit the following:

* your code files @@MarkovModel.cpp@@ and @@MarkovModel.hpp@@
* your @@main.cpp@@ that does the text generation task (it may be named @@TextGenerator.cpp@@)
* the @@mmtest.cpp@@
* your Makefile or make instructions
* your @@ps6-readme.txt@@ file

->@@submit fredm 204-ps6 ''files''@@

!! Grading Rubric

|| border=0
||'''Feature''' ||'''Value''' ||'''Comment''' ||
||MM implemementation || 4 ||full & correct implementation=4 pts; nearly complete=3pts; part way=2 pts; started=1 pt||
||Text Generation implemementation || 2 ||full & correct implementation=2 pts; part way=1 pt; not=0 pt||
||Makefile || 2 ||Makefile or explicit build/link instructions included ||
||Exceptions implementation || 2 ||full & correct implementation=2 pts; part way=1 pt; not=0 pt||
||Readme || 2 ||discussion is expected -- at least mentioning something per section. ||
||'''Total''' || 12 || ||
to:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[http://groups.google.com/group/91-204-202-s14 | Discussion Group]]

91.204.202 Computing IV, Spring 2014 \\
'''Prof. Fred Martin''', (:html:)<a href="http://mailhide.recaptcha.net/d?k=01COSqrfJ-58cc94fQb2pI1A==&c=iZBP8kCznrjdnfw8QFFKADFtsIimnLdVHk581djoISQ=" onclick="window.open('http://mailhide.recaptcha.net/d?k=01COSqrfJ-58cc94fQb2pI1A==&c=iZBP8kCznrjdnfw8QFFKADFtsIimnLdVHk581djoISQ=', '', 'toolbar=0,scrollbars=0,location=0,statusbar=0, menubar=0,resizable=0,width=500,height=300'); return false;" title="Reveal this e-mail address">click for fred's email</a>(:htmlend:) \\
TA: Bhanu Khausik, bkaushik@cs.uml.edu \\
Mon/Wed/Fri, 10a &#150; 10:50a, OS402

!!Text

Materials for this course will provided on this site and in links to other sites. We will not use a textbook.

!!Rationale

As of Spring 2014, the catalog listing for 91.204 Computing IV [[http://www.uml.edu/Catalog/Courses/undergraduate/91-204.aspx|says]]:

->Development of large software projects. Software engineering principles and practice. Object-oriented analysis and design. CASE productivity aids. Development techniques for program-translation software and web software.

This is old, and we'll be shortly revising it to something more like:

->Advanced C++ programming, which deepens studentsí understanding of object-oriented analysis and design. Basic software engineering principles and practice, including documentation standards. Principles of large software projects, including work with APIs. Topics may include program translation, web software, parsing, and regular expressions.

But even this doesn't tell the whole story, because various faculty who have taught / are teaching the course do very different things:

* Prof. Xinwen Fu teaches principles of [[computer vision and practical applications using OpenCV->http://www.cs.uml.edu/~xinwenfu/Classes/91.204.201/91.204.201_Syllabus_SP2013.htm]]
* Prof. Jesse Heines teaches [[XML parsing and language processing->http://abraham.cs.uml.edu/~heines/91.204/91.204-2012-13f/classnotes.jsp]]
* (former UML) Prof. Li Xu taught [[a 6-week module on compiler design->http://dl.acm.org/citation.cfm?id=1121370)]]
* Prof. Bill Moloney used to teach [[how to build a calculator using Lex and Yacc (i.e., parsing and grammars)->https://web.archive.org/web/20010803022749/http://www.cs.uml.edu/~bill/cs204/]]
* Prof. Emeritus Bob Lechner says the course used to be about building a linker (personal conversation)

Probably the only thing that can strongly be claimed about the course throughout the years is &#147;do stuff in C++, &#148; &#147;have the students write lots of code,&#148; and &#147;do cool stuff.&#148; (Of course, this last one depends on one's definition of cool.)

I'd also say that there definitely existed a point in time when having all students learn how to write a linker was absolutely the correct answer.

Now in Spring 2014 though, the course is an oddball in that it's required, but it's allowed to vary a lot based on instructor interests.

So, what will be doing in my class this semester?

* We will definitely be writing lots of code
* We will be doing it in C++
* We will be using some pretty cool APIs, including [[SFML->http://sfml-dev.org]], a free, open-source &#147;simple fast media library&#147; for C++, which is available for Mac, Win, and Linux (translation: it's a gaming library)
* Best of all, we'll be working through some awesome problem sets developed over the last 15 years at Princeton by Robert Sedgewick.

The Princeton stuff is great because it's all about how computing connects to the larger world.

It's not the usual stuff about using computing to do ever-more complicated things. This is necessary and valuable, but it's kind of self-referential and insular. Dare I say, incenstuous.

Here are some of things we'll be doing:

* Using Newton's laws of planetary motion and the &#147;leapfrog finite difference approximation&#148; method (don't worry; it's easy) to create a totally realistic simulation of our solar system&#151;complete with live animation

* Comparing sequence strings based on their on their &#147;edit distance&#148;&#151;a technique widely used in bioinformatics for DNA analysis

* Using a linear feedback shift register to cryptographically encode and decode an image

* Simulating the vibration of a guitar string, with a thing called the &#147;Karplus-Strong algorithm (also not too bad). This will include generating actual audio files and listening to them

Also in a partnership with [[Kronos->http://www.kronos.com/]], a Chelmsford, MA-based company which happens to be the largest employer of software developers that has its headquarters in MA:

* Parsing 0.5 MB error logs generated by malfunctioning InTouch devices, their hardware time-clock unit. Note: these are not neatly well-formed like proper XML!

Based on the historical role of the course in UMass Lowell's computer science curriculum, and my hopes/plans for the semester, I shall predict the following learning outcomes:

* You will become much more comfortable writing C++ code and using object-oriented methods.
* You will gain experience architecting solutions to reasonably well-structured problems.
* You will learn how to use some great C++ APIs (not only SFML, but Boost&#151;by the way, we're going to be doing some unit testing stuff).
* You'll gain practice with the most important thing about documentation, which is: Naming. Stuff. Well.

Collectively, these things represent to me what is the most important learning outcome of the course, which is you progressing down your journey of becoming an effective and confident software engineer.

Also, I won't be teaching you to use an IDE. You are welcome to use your favorite one, but I won't be requiring their use nor teaching them.

I do hope you all share your favorite development environments with each other.

When I do stuff with you in class, you'll be seeing Emacs, the Unix shell, and Makefiles.

Also #2, you're welcome to use your favorite platform (as long as it is one of Linux, Mac OS X, or Windows).

* I'll be using Linux. If you don't have a strong preference you should choose that.
* I can provide you with some help for Mac, as long as you're not using Xcode.
* If you're on Windows, that's fine, but you'll need to turn to your classmates for support.

OK, that's the course overview! Now on to some more tactical things.

!!Course Structure and Grading

The class will have regular weekly assignments, which will be graded and returned.

Cumulatively these assignments are worth 50% of your overall grade.

Assignments will be accepted up to 1 week late with a 50% reduction in that assignment's value. If you fall behind on your homework, it is much better to cut your losses and work on the current assignment, instead of running behind trying to catch up.

There will be two in-class exams during the semester. Each is worth 10% of your overall grade.

''Note:''
->I am aware it is a good teaching practice to announce the dates of in-class exams on the first day of class. I apologize that I am not doing this. It's because I prefer to schedule these exams when I may be away, and I'm not sure of those dates now. I will make sure to give you two weeks' notice for all in-class exames.

There will be a cumulative final, worth 20% of your overall grade.

Classroom participation is worth 10% of your overall grade. In practice, if your other grades put you on a marking boundary, this will push it one way or the other.

'''To summarize:'''\\
50% Weekly homeworks \\
20% Two exams \\
20% Final \\
10% Classroom participation \\

!!Discussion Group / E-Mail List

We will use Google Groups for class conversation and announcements. Please join this group.

There are two ways to sign up:

* (better) Log in to your Google account, go to [[https://groups.google.com/forum/#!forum/91-204-202-s14]], and request to join, or

* (easy but then no web access) Enter your preferred email in the box below.

(:html:)
<table style="border:1px solid #aa0033; font-size:small" align=center>
<tr>
<td rowspan=3>
<img src="http://www.cs.uml.edu/ecg/uploads/OPLspr14/googlegroups_logo.gif" height=58 width=150 alt="Google Groups">
</td>
<td colspan=2 align=center><b>Subscribe to 91-204-202-s14</b></td>
</tr>
<form action="http://groups.google.com/group/91-204-202-s14/boxsubscribe">
<tr>
<td>Email: <input type=text name=email></td>
<td>
<table
style="background-color:#ffcc33;padding:2px;border:2px outset #ffcc33;">
<tr>
<td>
<input type=submit name="sub" value="Request">
</td>
</tr>
</table>
</td>
</tr>
</form>
<tr><td colspan=2 align=center>
<a href="http://groups.google.com/group/91-204-202-s14" target="new">Browse Archives</a>
</td></tr>
</table>
(:htmlend:)

If you do the Google web method, I'd advise setting your preferences to immediate, individual delivery of messages&#151;click the &#147;Edit my membership&#148; tab.

If you do the email method, and you provide an address that's not linked to your Google account, I'll choose those delivery options for you, and then if you don't like it you'll have to ask me to change it, and we'll both be annoyed, so don't do that.

In either case you can send email to the list with [[mailto:91-204-202-s14@googlegroups.com]].

If you sign up on the web, you can browse conversations at the group link (see top of this page).

!!Lecture blog and lecture capture

I will strive to maintain a daily blog of highlights of what happened in class each class meeting. These notes will be recorded in the [[Lecture Blog]] page.

In-class activity will be recorded using the University's Echo360 lecture capture system. This material is intended for your use if you must miss class, or if you want to go over again something that was presented/discussed in class.

A link to the Echo360 recordings is at the top of the [[Lecture Blog]] page.

Echo360 makes a high quality recording of the classroom's data projector and the instructor's voice.

It also produces a low-resolution recording of the front of the room (i.e., me walking around writing stuff on the white board), and a low-volume capture of student remarks (depending how close to the microphone you're sitting, and how loud you are).

If you arrive at class after 10a, and walk across the front of the room, you'll be captured by the low-res overview cam.

If you're a talker and you're at a decent volume and near a mic, people will be able to hear you on the recording. (They won't see you sitting in your chair&#151;maybe the back of your head if you're at the front of the room.)

If it bothers you that your voice will be captured, and you want to feel comfortable speaking up, please let our TA know and the TA will anonymously refer your concerns to me. We'll set up the captures in a more private way.

!!Collaboration policy

'''Individual work.''' Most assignments must be completed individually. You are welcome to discuss ideas in the class with your peers. You may not look at each others' code, nor allow others to look at your code. If you need to post code on our own course forum for help, or a public forum, do not post more than three lines.

When turning in an individual assignment, you attest that, beyond any starter code I have provided or has been provided in standard API and reference documentation, you are the sole author the code that it includes.

'''Pair programming.''' A few specific assignments may allow pair programming. There will be highly structured rules for these (which are intended to make sure both partners have a substantial learning experience).

This will be discussed later in class, and this document will be updated at that time.

'''Academic integrity.''' Please be familiar with the university's [[policy on academic integrity->https://www.uml.edu/Catalog/Undergraduate/Policies/Academic-Integrity.aspx]].
April 07, 2014, at 08:48 PM by 192.168.0.12 -
Changed line 76 from:
->This will be useful when implementing the @@randk@@ method, so that you can produce all of the ''k+1''-grams that will follow the provided kgram, test for the frequency of each ''k+1''-gram, and then produce output characters with proportional frequencies.
to:
->This will be useful when implementing the @@randk@@ method, so that you can produce all of the ''k+1''-grams that may follow the provided kgram, test for the frequency of each ''k+1''-gram, and then produce output characters with proportional frequencies.
April 07, 2014, at 08:47 PM by 192.168.0.12 -
Changed lines 1-182 from:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[http://groups.google.com/group/91-204-202-s14 | Discussion Group]]

91.204.202 Computing IV, Spring 2014 \\
'''Prof. Fred Martin''', (:html:)<a href="http://mailhide.recaptcha.net/d?k=01COSqrfJ-58cc94fQb2pI1A==&c=iZBP8kCznrjdnfw8QFFKADFtsIimnLdVHk581djoISQ=" onclick="window.open('http://mailhide.recaptcha.net/d?k=01COSqrfJ-58cc94fQb2pI1A==&c=iZBP8kCznrjdnfw8QFFKADFtsIimnLdVHk581djoISQ=', '', 'toolbar=0,scrollbars=0,location=0,statusbar=0, menubar=0,resizable=0,width=500,height=300'); return false;" title="Reveal this e-mail address">click for fred's email</a>(:htmlend:) \\
TA:  Bhanu Khausik, bkaushik@cs.uml.edu \\
Mon/Wed/Fri, 10a &#150; 10:50a, OS402

!!Text

Materials for this course will provided on this site and in links to other sites. We will not use a textbook.

!!Rationale

As of Spring 2014, the catalog listing for  91.204 Computing IV [[http://www.uml.edu/Catalog/Courses/undergraduate/91-204.aspx|says]]:

->Development of large software projects. Software engineering principles and practice. Object-oriented analysis and design. CASE productivity aids. Development techniques for program-translation software and web software.

This is old, and we'll be shortly revising it to something more like:

->Advanced C++ programming, which deepens studentsí understanding of object-oriented analysis and design. Basic software engineering principles and practice, including documentation standards. Principles of large software projects, including work with APIs. Topics may include program translation, web software, parsing, and regular expressions.

But even this doesn't tell the whole story, because various faculty who have taught / are teaching the course do very different things:

* Prof. Xinwen Fu teaches principles of [[computer vision and practical applications using OpenCV->http://www.cs.uml.edu/~xinwenfu/Classes/91.204.201/91.204.201_Syllabus_SP2013.htm]]
* Prof. Jesse Heines teaches [[XML parsing and language processing->http://abraham.cs.uml.edu/~heines/91.204/91.204-2012-13f/classnotes.jsp]]
* (former UML) Prof. Li Xu taught [[a 6-week module on compiler design->http://dl.acm.org/citation.cfm?id=1121370)]]
* Prof. Bill Moloney used to teach [[how to build a calculator using Lex and Yacc (i.e., parsing and grammars)->https://web.archive.org/web/20010803022749/http://www.cs.uml.edu/~bill/cs204/]]
* Prof. Emeritus Bob Lechner says the course used to be about building a linker (personal conversation)

Probably the only thing that can strongly be claimed about the course throughout the years is &#147;do stuff in C++, &#148; &#147;have the students write lots of code,&#148; and &#147;do cool stuff.&#148; (Of course, this last one depends on one's definition of cool.)

I'd also say that there definitely existed a point in time when having all students learn how to write a linker was absolutely the correct answer.

Now in Spring 2014 though, the course is an oddball in that it's required, but it's allowed to vary a lot based on instructor interests.

So, what will be doing in my class this semester?

* We will definitely be writing lots of code
* We will be doing it in C++
* We will be using some pretty cool APIs, including [[SFML->http://sfml-dev.org]], a free, open-source &#147;simple fast media library&#147; for C++, which is available for Mac, Win, and Linux (translation: it's a gaming library)
* Best of all, we'll be working through some awesome problem sets developed over the last 15 years at Princeton by Robert Sedgewick.

The Princeton stuff is great because it's all about how computing connects to the larger world.

It's not the usual stuff about using computing to do ever-more complicated things. This is necessary and valuable, but it's kind of self-referential and insular. Dare I say, incenstuous.

Here are some of things we'll be doing:

* Using Newton's laws of planetary motion and the &#147;leapfrog finite difference approximation&#148; method (don't worry; it's easy) to create a totally realistic simulation of our solar system&#151;complete with live animation

* Comparing sequence strings based on their on their &#147;edit distance&#148;&#151;a technique widely used in bioinformatics for DNA analysis

* Using a linear feedback shift register to cryptographically encode and decode an image

* Simulating the vibration of a guitar string, with a thing called the &#147;Karplus-Strong algorithm (also not too bad). This will include generating actual audio files and listening to them

Also in a partnership with [[Kronos->http://www.kronos.com/]], a Chelmsford, MA-based company which happens to be the largest employer of software developers that has its headquarters in MA:

* Parsing 0.5 MB error logs generated by malfunctioning InTouch devices, their hardware time-clock unit. Note: these are not neatly well-formed like proper XML!

Based on the historical role of the course in UMass Lowell's computer science curriculum, and my hopes/plans for the semester, I shall predict the following learning outcomes:

* You will become much more comfortable writing C++ code and using object-oriented methods.
* You will gain experience architecting solutions to reasonably well-structured problems.
* You will learn how to use some great C++ APIs (not only SFML, but Boost&#151;by the way, we're going to be doing some unit testing stuff).
* You'll gain practice with the most important thing about documentation, which is: Naming. Stuff. Well.

Collectively, these things represent to me what is the most important learning outcome of the course, which is you progressing down your journey of becoming an effective and confident software engineer.

Also, I won't be teaching you to use an IDE. You are welcome to use your favorite one, but I won't be requiring their use nor teaching them.

I do hope you all share your favorite development environments with each other.

When I do stuff with you in class, you'll be seeing Emacs, the Unix shell, and Makefiles.

Also #2, you're welcome to use your favorite platform (as long as it is one of Linux, Mac OS X, or Windows).

* I'll be using Linux. If you don't have a strong preference you should choose that.
* I can provide you with some help for Mac, as long as you're not using Xcode.
* If you're on Windows, that's fine, but you'll need to turn to your classmates for support.

OK, that's the course overview! Now on to some more tactical things.

!!Course Structure and Grading

The class will have regular weekly assignments, which will be graded and returned.

Cumulatively these assignments are worth 50% of your overall grade.

Assignments will be accepted up to 1 week late with a 50% reduction in that assignment's value. If you fall behind on your homework, it is much better to cut your losses and work on the current assignment, instead of running behind trying to catch up.

There will be two in-class exams during the semester.  Each is worth 10% of your overall grade.

''Note:''
->I am aware it is a good teaching practice to announce the dates of in-class exams on the first day of class. I apologize that I am not doing this. It's because I prefer to schedule these exams when I may be away, and I'm not sure of those dates now. I will make sure to give you two weeks' notice for all in-class exames.

There will be a cumulative final, worth 20% of your overall grade.

Classroom participation is worth 10% of your overall grade.  In practice, if your other grades put you on a marking boundary, this will push it one way or the other.

'''To summarize:'''\\
50% Weekly homeworks \\
20% Two exams \\
20% Final \\
10% Classroom participation \\

!!Discussion Group / E-Mail List

We will use Google Groups for class conversation and announcements.  Please join this group.

There are two ways to sign up:

* (better) Log in to your Google account, go to [[https://groups.google.com/forum/#!forum/91-204-202-s14]], and request to join, or

* (easy but then no web access) Enter your preferred email in the box below.

(:html:)
<table style="border:1px solid #aa0033; font-size:small" align=center>
  <tr>
    <td rowspan=3>
    <img src="http://www.cs.uml.edu/ecg/uploads/OPLspr14/googlegroups_logo.gif" height=58 width=150 alt="Google Groups">
    </td>
    <td colspan=2 align=center><b>Subscribe to 91-204-202-s14</b></td>
  </tr>
  <form action="http://groups.google.com/group/91-204-202-s14/boxsubscribe">
  <tr>
    <td>Email: <input type=text name=email></td>
    <td>
      <table
      style="background-color:#ffcc33;padding:2px;border:2px outset #ffcc33;">
      <tr>
        <td>
        <input type=submit name="sub" value="Request">
        </td>
      </tr>
      </table>
    </td>
  </tr>
  </form>
  <tr><td colspan=2 align=center>
  <a href="http://groups.google.com/group/91-204-202-s14" target="new">Browse Archives</a>
  </td></tr>
</table>
(:htmlend:)

If you do the Google web method, I'd advise setting your preferences to immediate, individual delivery of messages&#151;click the &#147;Edit my membership&#148; tab.

If you do the email method, and you provide an address that's not linked to your Google account, I'll choose those delivery options for you, and then if you don't like it you'll have to ask me to change it, and we'll both be annoyed, so don't do that.

In either case you can send email to the list with [[mailto:91-204-202-s14@googlegroups.com]].

If you sign up on the web, you can browse conversations at the group link (see top of this page).

!!Lecture blog and lecture capture

I will strive to maintain a daily blog of highlights of what happened in class each class meeting. These notes will be recorded in the [[Lecture Blog]] page.

In-class activity will be recorded using the University's Echo360 lecture capture system. This material is intended for your use if you must miss class, or if you want to go over again something that was presented/discussed in class.

A link to the Echo360 recordings is at the top of the [[Lecture Blog]] page.

Echo360 makes a high quality recording of the classroom's data projector and the instructor's voice.

It also produces a low-resolution recording of the front of the room (i.e., me walking around writing stuff on the white board), and a low-volume capture of student remarks (depending how close to the microphone you're sitting, and how loud you are).

If you arrive at class after 10a, and walk across the front of the room, you'll be captured by the low-res overview cam.

If you're a talker and you're at a decent volume and near a mic, people will be able to hear you on the recording. (They won't see you sitting in your chair&#151;maybe the back of your head if you're at the front of the room.)

If it bothers you that your voice will be captured, and you want to feel comfortable speaking up, please let our TA know and the TA will anonymously refer your concerns to me. We'll set up the captures in a more private way.

!!Collaboration policy

'''Individual work.''' Most assignments must be completed individually. You are welcome to discuss ideas in the class with your peers. You may not look at each others' code, nor allow others to look at your code. If you need to post code on our own course forum for help, or a public forum, do not post more than three lines.

When turning in an individual assignment, you attest that, beyond any starter code I have provided or has been provided in standard API and reference documentation, you are the sole author the code that it includes.

'''Pair programming.''' A few specific assignments may allow pair programming. There will be highly structured rules for these (which are intended to make sure both partners have a substantial learning experience).

This will be discussed later in class, and this document will be updated at that time.

'''Academic integrity.''' Please be familiar with the university's [[policy on academic integrity->https://www.uml.edu/Catalog/Undergraduate/Policies/Academic-Integrity.aspx]].
to:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[https://groups.google.com/forum/#!forum/91-204-202-s14 | Discussion Group]]

! Markov Model of Natural Language

In this assignment, we analyze an input text for transitions between ''k-grams'' (a fixed number of characters) and the following letter.

Then we produce a probabilistic model of the text: given a particular ''k-gram'' series of letters, what letters follow at what probabilities?

Then we use the model to generate nonsense text that's surprisingly reasonable.

See the full assignment at the Princeton site: http://www.cs.princeton.edu/courses/archive/fall13/cos126/assignments/markov.html

!! Implementation

Begin by implementing the following class:

[@
class MarkovModel
----------------------------------------------------------------------------------------
// Note: all of the below constructors/methods should be public.

      MarkovModel(string text, int k)// create a Markov model of order k from given text
                                      // Assume that text has length at least k.

  int order()                        // order k of Markov model

  int freq(string kgram)            // number of occurrences of kgram in text
                                      // (throw an exception if kgram is not of length k)

  int freq(string kgram, char c)    // number of times that character c follows kgram
                                      // if order=0, return num of times char c appears
                                      // (throw an exception if kgram is not of length k)


  char randk(string kgram)            // random character following given kgram
                                      // (Throw an exception if kgram is not of length k.
                                      //  Throw an exception if no such kgram.)

string gen(string kgram, int T)      // generate a string of length T characters
                                      // by simulating a trajectory through the corresponding
                                      // Markov chain.  The first k characters of the newly
                                      // generated string should be the argument kgram.
                                      // Throw an exception if kgram is not of length k.
                                      // Assume that T is at least k.

          <<                        // overload the stream insertion operator and display
                                      // the internal state of the Markov Model. Print out
                                      // the order, the alphabet, and the frequencies of
                                      // the k-grams and k+1-grams.
@]

!! Details

* This is the same as the Princeton spec except that the class method @@rand@@ has been renamed @@randk@@.

* Here is a header file to get you started: Attach:MarkovModel.hpp.

* Make sure you throw @@std::runtime_error@@'s in the methods per the spec. Review how to do this in [[PS5a]].

* Test your implementation against the following test file: Attach:mmtest.cpp.

* Consider the behavior of a 0-order model. This model will generate new characters with a distribution proportional to the ratio they appear in the input text. This model is context-free; it does not use an input kgram (representing the current state of the model) when generating a new character. As such:

** The @@freq(string kgram)@@ method takes an empty string as its input kgram (length of kgram must equal the order of the model).

** This method call should produce as a result the length of the original input text (given in the constructor).

** The @@freq(string kgram, char c)@@ also will take a null string as input. It should produce as output the number of times the character @@c@@ appears in the original input text.

* Per discussion in class, consider using a C++ map (http://www.cplusplus.com/reference/map/map/) store frequency counts of each kgram and ``k+1''-gram as it's encountered when you traverse the string in the constructor.

* Make sure to wrap around the end of the string during traversal, as described in the Princeton assignment.

* At construction time, it is highly recommended to build up a string that represents the active alphabet and store it as a private class member variable.

->This will be useful when implementing the @@randk@@ method, so that you can produce all of the ''k+1''-grams that will follow the provided kgram, test for the frequency of each ''k+1''-gram, and then produce output characters with proportional frequencies.

->Make sure to use the map's @@find@@ or @@count@@ methods to test for the existence of hypothetical ''k+1'' grams. If you use the map's @@[]@@ operator or @@at@@ accessor, you'll create an entry in the map for the ''k+1''-gram&#151;even if it's never encountered in the input. This would be quite wasteful of space. So use @@find@@ or @@count@@ to test for its existence without creating it.

* See Willie Boag's suggestion in the discussion group for how to generate output characters that follow the probability distribution that's discovered in the input: [[https://groups.google.com/forum/#!topic/91-204-202-s14/16yuB54d5Fw]]. You don't have to do it this way; it's just a suggestion.

* ''Overload stream insertion operator to display internal state of Markov model:'' See these sample instructions for [[how to do the overload->http://www.learncpp.com/cpp-tutorial/93-overloading-the-io-operators/]]. You should print out all of the ''k''-gram and ''k+1''-gram frequencies, the order of the model, and its alphabet. Here are sample instructions for [[how to build an iterator over the map->http://stackoverflow.com/questions/4844886/how-to-loop-through-a-c-map]] of ''k''-gram and ''k+1''-gram keys.

* Create a Makefile or include short, direct instructions for how to build your project.

* Fill out the [[Attach:ps6-readme.txt]].

!! Submit

Submit the following:

* your code files @@MarkovModel.cpp@@ and @@MarkovModel.hpp@@
* your @@main.cpp@@ that does the text generation task (it may be named @@TextGenerator.cpp@@)
* the @@mmtest.cpp@@
* your Makefile or make instructions
* your @@ps6-readme.txt@@ file

->@@submit fredm 204-ps6 ''files''@@

!! Grading Rubric

|| border=0
||'''Feature''' ||'''Value''' ||'''Comment''' ||
||MM implemementation || 4 ||full & correct implementation=4 pts; nearly complete=3pts; part way=2 pts; started=1 pt||
||Text Generation implemementation || 2 ||full & correct implementation=2 pts; part way=1 pt; not=0 pt||
||Makefile || 2 ||Makefile or explicit build/link instructions included ||
||Exceptions implementation || 2 ||full & correct implementation=2 pts; part way=1 pt; not=0 pt||
||Readme || 2 ||discussion is expected -- at least mentioning something per section. ||
||'''Total''' || 12 || ||
April 06, 2014, at 02:52 PM by 192.168.0.12 -
Changed lines 10-12 from:
We will not use a textbook.

Materials for
this course will provided on this site and in links to other sites.
to:
Materials for this course will provided on this site and in links to other sites. We will not use a textbook.
April 06, 2014, at 02:51 PM by 192.168.0.12 -
Changed line 5 from:
TA:  TBA \\
to:
TA:  Bhanu Khausik, bkaushik@cs.uml.edu \\
Changed line 184 from:
'''Academic integrity.''' Please be familiar with the university's [[policy on academic integrity->https://www.uml.edu/Catalog/Undergraduate/Policies/Academic-Integrity.aspx]].
to:
'''Academic integrity.''' Please be familiar with the university's [[policy on academic integrity->https://www.uml.edu/Catalog/Undergraduate/Policies/Academic-Integrity.aspx]].
Changed line 1 from:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[https://groups.google.com/forum/#!forum/91-204-202-s14 | Discussion Group]]
to:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[http://groups.google.com/group/91-204-202-s14 | Discussion Group]]
Changed lines 97-98 from:
->I am aware it is a good teaching practice to announce the dates of in-class exams on the first day of class. I apologize that I am not doing this. It's primarily because I prefer to schedule these exams when I am away, and I'm not sure of those dates now. I will make sure to give you two weeks' notice for all in-class exames.
to:
->I am aware it is a good teaching practice to announce the dates of in-class exams on the first day of class. I apologize that I am not doing this. It's because I prefer to schedule these exams when I may be away, and I'm not sure of those dates now. I will make sure to give you two weeks' notice for all in-class exames.
Changed line 105 from:
10% Two exams \\
to:
20% Two exams \\
Changed line 150 from:
If you do the email method, I'll choose that for you, and then if you don't like it you'll have to ask me to change it, and we'll both be annoyed, so don't do that.
to:
If you do the email method, and you provide an address that's not linked to your Google account, I'll choose those delivery options for you, and then if you don't like it you'll have to ask me to change it, and we'll both be annoyed, so don't do that.
Deleted lines 155-167:
!!Collaboration policy

'''Individual work.''' Most assignments must be completed individually. You are welcome to discuss ideas in the class with your peers. You may not look at each others' code, nor allow others to look at your code. If you need to post code on our own course forum for help, or a public forum, do not post more than three lines.

When turning in an individual assignment, you attest that, beyond any starter code I have provided or has been provided in standard API and reference documentation, you are the sole author the code that it includes.

'''Pair programming.''' A few specific assignments may allow pair programming. There will be highly structured rules for these (which are intended to make sure both partners have a substantial learning experience).

This will be discussed later in class, and this document will be updated at that time.

'''Academic integrity.''' Please be familiar with the university's [[policy on academic integrity->https://www.uml.edu/Catalog/Undergraduate/Policies/Academic-Integrity.aspx]].

Added lines 174-184:
!!Collaboration policy

'''Individual work.''' Most assignments must be completed individually. You are welcome to discuss ideas in the class with your peers. You may not look at each others' code, nor allow others to look at your code. If you need to post code on our own course forum for help, or a public forum, do not post more than three lines.

When turning in an individual assignment, you attest that, beyond any starter code I have provided or has been provided in standard API and reference documentation, you are the sole author the code that it includes.

'''Pair programming.''' A few specific assignments may allow pair programming. There will be highly structured rules for these (which are intended to make sure both partners have a substantial learning experience).

This will be discussed later in class, and this document will be updated at that time.

'''Academic integrity.''' Please be familiar with the university's [[policy on academic integrity->https://www.uml.edu/Catalog/Undergraduate/Policies/Academic-Integrity.aspx]].
Changed line 148 from:
If you do the web method, I'd advise setting your preferences to immediate, individual delivery of messages&#151;click the &#147;Edit my membership&#148; tab.
to:
If you do the Google web method, I'd advise setting your preferences to immediate, individual delivery of messages&#151;click the &#147;Edit my membership&#148; tab.
Changed lines 111-112 from:
We will use Google Groups for class conversation and announcements.  Please join this group.  I'd advise setting your preferences to immediate, individual delivery of messages&#151;click the &#147;Edit my membership&#148; tab.
to:
We will use Google Groups for class conversation and announcements.  Please join this group.

There are two ways to sign up:

* (better) Log in to your Google account, go to [[https://groups.google.com/forum/#!forum/91-204-202-s14]], and request to join, or

* (easy but then no web access) Enter your preferred email in the box below
.
Changed lines 148-154 from:
The group address is mailto:91-204-202-s14@googlegroups.com. You have to be a member to send to the list.
to:
If you do the web method, I'd advise setting your preferences to immediate, individual delivery of messages&#151;click the &#147;Edit my membership&#148; tab.

If you do the email method, I'll choose that for you, and then if you don't like it you'll have to ask me to change it, and we'll both be annoyed, so don't do that.

In either case you can send email to the list with [[mailto:91-204-202-s14@googlegroups.com]].

If you sign up on the web, you can browse conversations at the group link (see top of this page)
.
Changed lines 72-73 from:
Also, I won't be teaching you to use an IDE. You are welcome to use your favorite one, but I won't be requiring their use nor teaching about them. I do hope you all share your favorite environments with each other. When I do stuff with you in class, you'll be seeing Emacs, the Unix shell, and Makefiles.
to:
Also, I won't be teaching you to use an IDE. You are welcome to use your favorite one, but I won't be requiring their use nor teaching them.

I
do hope you all share your favorite development environments with each other.

When I do stuff with you in class, you'll be seeing Emacs, the Unix shell, and Makefiles.
Added line 79:
Changed lines 88-89 from:
The class will have regular weekly assignments, which will be graded and returned.  Cumulatively these assignments are worth 50% of your overall grade.  Assignments will be accepted up to 1 week late with a 50% reduction in that assignment's value.  If you fall behind on your homework, it is much better to cut your losses and work on the current assignment, instead of running behind trying to catch up.
to:
The class will have regular weekly assignments, which will be graded and returned.

Cumulatively these assignments are worth
50% of your overall grade.

Assignments will be accepted up to 1 week late with a
50% reduction in that assignment's value. If you fall behind on your homework, it is much better to cut your losses and work on the current assignment, instead of running behind trying to catch up.
Changed lines 97-98 from:
->I am aware it is a good teaching practice to announce when the in-class exams will occur on the first day of class. I apologize that I am not doing this. It's primarily because I prefer to schedule these exams when I am away, and I'm not sure of those dates now. I will make sure to give you two weeks' notice for all in-class exames.
to:
->I am aware it is a good teaching practice to announce the dates of in-class exams on the first day of class. I apologize that I am not doing this. It's primarily because I prefer to schedule these exams when I am away, and I'm not sure of those dates now. I will make sure to give you two weeks' notice for all in-class exames.
Added line 103:
'''To summarize:'''\\
Changed line 119 from:
   <td colspan=2 align=center><b>Subscribe to 91301-s14</b></td>
to:
   <td colspan=2 align=center><b>Subscribe to 91-204-202-s14</b></td>
Changed line 121 from:
  <form action="http://groups.google.com/group/91301-s14/boxsubscribe">
to:
  <form action="http://groups.google.com/group/91-204-202-s14/boxsubscribe">
Changed line 137 from:
   <a href="http://groups.google.com/group/91301-s14" target="new">Browse Archives</a>
to:
   <a href="http://groups.google.com/group/91-204-202-s14" target="new">Browse Archives</a>
Changed lines 142-154 from:
The group address is mailto:91301-s14@googlegroups.com.  You have to be a member to send to the list.

!!Collaboration Policy

You are welcome to discuss ideas in the class with your peers.  However, pair programming or other sharing of code is
not allowed.  By turning in an assignment, you attest that ''you have written'' the code that it includes. Please be familiar with the university's [[academic integrity policy->http://www.uml.edu/catalog/undergraduate/policies/academic_dishonesty.htm]].

!!Honors Section

Students who are registered for the honors section of the class are expected to have exemplary work, including classroom participation, written work
, and the course project. Additional and more difficult problems will be assigned in most of the weekly problem sets.

!!Acknowledgment

Much of this course design is based on work done by UML Prof
. Holly Yanco.
to:
The group address is mailto:91-204-202-s14@googlegroups.com. You have to be a member to send to the list.

!!Collaboration policy

'''Individual work.''' Most assignments must be completed individually. You are welcome to discuss ideas in the class with your peers. You may
not look at each others' code, nor allow others to look at your code. If you need to post code on our own course forum for help, or a public forum, do not post more than three lines.

When turning in an individual assignment, you attest that
, beyond any starter code I have provided or has been provided in standard API and reference documentation, you are the sole author the code that it includes.

'''Pair programming
.''' A few specific assignments may allow pair programming. There will be highly structured rules for these (which are intended to make sure both partners have a substantial learning experience).

This will be discussed later in class, and this document will be updated at that time.

'''Academic integrity.''' Please be familiar with the university's [[policy on academic integrity->https://www.uml.edu/Catalog/Undergraduate/Policies/Academic-Integrity.aspx]].


!!Lecture blog and lecture capture

I will strive to maintain a daily blog of highlights of what happened in class each class meeting. These notes will be recorded in the [[Lecture Blog]] page.

In-class activity will be recorded using the University's Echo360 lecture capture system. This material is intended for your use if you must miss class, or if you want to go over again something that was presented/discussed in class.

A link to the Echo360 recordings is at the top of the [[Lecture Blog]] page.

Echo360 makes a high quality recording of the classroom's data projector and the instructor's voice.

It also produces a low-resolution recording of the front of the room (i.e., me walking around writing stuff on the white board), and a low-volume capture of student remarks (depending how close to the microphone you're sitting, and how loud you are).

If you arrive at class after 10a, and walk across the front of the room, you'll be captured by the low-res overview cam.

If you're a talker and you're at a decent volume and near a mic, people will be able to hear you on the recording. (They won't see you sitting in your chair&#151;maybe the back of your head if you're at the front of the room.)

If it bothers you that your voice will be captured, and you want to feel comfortable speaking up, please let our TA know and the TA will anonymously refer your concerns to me. We'll set up the captures in a more private way.

Changed lines 51-56 from:
* Using Newton's laws of planetary motion and the &#147;leapfrog finite difference approximation&#148; method (don't worry; it's not hard) to create a totally realistic simulation of our solar system&#151;complete with live animation

* DNA analysis techniques widely used in bioinformatics, based on the concept of comparing sequence-strings on their &#147;edit distance&#148;

* Cryptographic techniques using a linear feedback shift register&#151;including encoding and decoding an image
to:
* Using Newton's laws of planetary motion and the &#147;leapfrog finite difference approximation&#148; method (don't worry; it's easy) to create a totally realistic simulation of our solar system&#151;complete with live animation

* Comparing sequence strings based on their on their &#147;edit distance&#148;&#151;a technique widely used in bioinformatics for DNA analysis

* Using a linear feedback shift register to cryptographically encode and decode an image
Changed lines 61-64 from:
* Techniques for parsing 0.5 MB error logs generated by failed InTouch devices, their hardware time-clock unit. Note: these are not neatly well-formed like proper XML!

Based on the historical role of the course in UMass Lowell's computer science curriculum, and my hopes/plans for the semester, I'd like to predict the following learning outcomes:
to:
* Parsing 0.5 MB error logs generated by malfunctioning InTouch devices, their hardware time-clock unit. Note: these are not neatly well-formed like proper XML!

Based on the historical role of the course in UMass Lowell's computer science curriculum, and my hopes/plans for the semester, I shall predict the following learning outcomes:
Deleted lines 80-143:








In my opinion, this course exists to give you a different way of thinking about computing.  A way that is really quite apart from the &#147;professional&#148; programming languages like C, C++, and Java, all of which are based on an edit/compile/debug/deploy model of computation.

There are basically two variants of the OPL-type course at CS departments.  One variant is a survey of the ideas in many languages that have been created and implemented.  The other variant is a deep-dive into a language favored by language researchers, often Scheme or CAML.  Both of these languages are &#147;meta-languages&#148;&#151;they are languages for making languages.

At UMass Lowell, we take the 2nd approach (deep dive) in our undergrad course, and the survey approach in our grad class.  For many years here, 91.301 has been a close implementation of the famous &#147;6.001&#148; course at MIT, ''Structure and Interpretation of Computer Programs.'' This course was created in the 1970s and has been hugely influential. 

Now, it so happens that MIT has just implemented a major overhaul of their undergrad EECS curriculum, and as of Fall 2008, the 6.001 course is no longer being offered. Given that, why are we still teaching it, you might ask?

!!Isn&#146;t Scheme a Dead Language? (aka, Why do I have to take this class?)

Scheme isn't exactly dead.  There is a committed community involved in on-going development of the version of Scheme we'll be using (Racket).  Scheme itself is a streamlined, pedagogically pure version of Lisp; Lisp is an expanded version of the language, with lots of libraries useful in real-world applications.  While not hugely popular, there are still significant real-world systems being built in Lisp.  The [[Attach:itastory.pdf|Orbitz flight reservation system]] is a leading example.

More importantly, the ''ideas behind Scheme''&#151;e.g., functional programming&#151;are valuable, even if you're not coding in Scheme. 

* Jane St. Capital, a Wall Street trading company, does a lot of programming in OCaml, and object-oriented functional programming language, and explicitly recruits Scheme programmers. (See their research paper at http://portal.acm.org/citation.cfm?id=1394798).

* It is now clear that processors aren't going to be getting faster at the rate they have been over the last 20 years, and that multi-core systems and their associated programming will be increasingly important in order to continue the performance gains we expect.  Functional programming is much easier to parallelize than traditional imperative styles, and many believe that expertise in thinking in functional ways is becoming more and more important.  See the recent Dr. Dobbs article, &#147;[[Attach:Dr_Dobbs_It_s_Time_to_Get_Good_at_Functional_Programming.pdf|It's Time to Get Good at Functional Programming.]]&#148;

* Many languages, including C++, now incorporate ideas that originated in Lisp/Scheme, including closures and anonymous functions.

* Aside from the particular concepts in Scheme or Lisp, they represent a fundamentally different approach to building languages than the dominant method, which is based on compilers and binary executables.  Scheme and Lisp are implemented as interpreters, and interpreters allow a much more iterative and interactive style of code development.  Python is the presently the most popular language that is based on the interpreter approach.  Also, interpreters are often built into domain-specific applications as powerful, accessible scripting environments within those applications; Tcl and [[Lua->http://en.wikipedia.org/wiki/Lua_(programming_language)]] are other languages often built into systems as interpreters.  [[AutoCAD->http://en.wikipedia.org/wiki/AutoLISP]] and [[GIMP->http://www.gimp.org/tutorials/Basic_Scheme/]] are two well-known systems that include Lisp or Scheme interpreters.

!!What Is The Big Idea Then?

There are actually several &#147;big ideas&#147; that we will bring out in OPL:

* '''Program-as-data.'''  In typical programming languages, there is a sharp distinction between what is code and what is data.  Data structures are allocated explicitly, and code is written to manipulate them.  The two things are of a different nature.  (Of course, &#147;bits are bits,&#148; but you're not going to be placing executable code into an array unless you're implementing a buffer overrun attack.) 

->But in Scheme, the fundamental notation for describing code and data (known as the ''S-expression'') is the same thing.  Data structures and executable procedures are both nested lists.  Furthermore, it is commonplace for code to produce data that is executed as code. 

->This leads to the next point...

* '''Functions as first-class objects.''' In Scheme, procedures (also known as functions) can accept procedures as inputs (arguments).  But they also can easily create procedures as outputs (return values).  This leads to a style of programming known as ''functional programming,'' in which functions are composed and applied to lists of data to produce results, instead of the more prevalent approach of sequentially manipulating data structures.

->Please don't confuse C/Java functions with Scheme-style functional programming.  In C and Java, functions are really ''imperative'' programming&#151;a series of commands&#151;with lots of side-effects (mutation of data structures and variable values).  In functional programming, given the same input, the result of evaluating a function is always the same (think mathematical functions).  There is no global or external state that gets involved. 

->Functional programming has some advantages in transparency and simplicity, particularly in language and symbolic processing, and is facilitated by a language like Scheme in which code can easily construct and output code on the fly.  Also, a functional program, with its lack of side-effects and mutation of data structures, is much easier to parallelize&#151;you can run multiple functions separately and concurrently, without worrying about them fighting over the same shared data structures.

* '''Data abstraction.'''  This was one of the really big contributions of SICP&#151;the idea of abstracting data structures from the interfaces for manipulating them.  It then becomes possible to re-implement an underlying data structure without changing the code that uses it.  For example, if there is a @@concatenate@@ operation that appends one string to another, code that uses @@concatenate@@ doesn't need to change even if the underlying representation of a string changes.

->This idea, which is of course the basis of object-oriented programming, is so well-established that it may now seem obvious. But this was hardly the case in the 1960s and 1970s when SICP was developed.  Scheme has a somewhat different way of bundling together data representations and the procedures (methods) for manipulating them, which allows a high degree of flexibility.

* '''The environment and persistence.''' In typical programming environments, data and objects are created anew each time the program launches.  If you need to return to a previous execution state, then you read in data (e.g., from files on the disk or off the net) and reconstitute the data structures that hold that data.  Object-oriented languages typically provide some way to serialize objects&#151;converting them into a flat-file format (e.g., XML) for saving and loading across execution runs.

->Scheme handles things totally differently.  Once you create an object, it's just there&#151;existing in the environment in which it was created.  As long has you have a &#147;handle&#148; to it (i.e., you've named it, or it's part of another object that you have access to), the object will persist.  When you quit Scheme, the entire environment including all objects gets saved to disk.  Next time you relaunch, you reload the environment file and everything is exactly as you left it.  (There once were Lisp Machines, and the concept of &#147;quitting Scheme&#148; didn't exist.)  Smalltalk, the language developed by Alan Kay as part of the [[Xerox Star project->http://en.wikipedia.org/wiki/Xerox_Star]] [a.k.a., the machine that led to the Macintosh and the WIMP windows-icon-mouse-pointer interface], also implemented code and data persistence through a [[saveable environment image->http://en.wikipedia.org/wiki/Smalltalk#Image-based_persistence]].  In fact, [[Squeak->http://www.squeak.org/]], a current implementation of Smalltalk, includes code and data objects that were created back in the 1970s during the original Smalltalk work&#151;as a &#147;sourdough yeast starter&#148; reproduces itself through the years.

->As part of the implementation of the environment, garbage collection was introduced.  Objects that had no way of being accessed (i.e., they had no names, no pointers to them) could be removed from memory, and the space they took up could then be freed for other purposes.  Once controversial because of its complexity, automatic garbage collection is now considered an obvious part of a modern language design.

* '''Interpretation and the Listener.''' Scheme was historically an interpreted language, and provided a &#147;Listener&#148; console for interactively constructing expressions and evaluating them.  (At one time, the fact that it was interpreted was considered a significant performance liability, but compiled versions of Scheme and Lisp now exist, removing this as a concern.) 

->Because of the Listener, developing Scheme programs feels quite different than working in a typical edit-compile-test language.  After a single procedure is defined, you can try it out interactively, giving it inputs and examining its outputs.  Combined with the concept of the environment, you end up iteratively and alternately developing data structures and the code for operating on them.

->When you become accustomed to the Listener, you feel stymied without it.  It becomes annoying to write @@main@@ functions simply for the purpose of exercising your routines&#151;why can't you just talk to them directly?  Similarly, the environment is a powerful construct&#151;you build up a library of objects that are part of your project, and once created, they are part of your software system.

->Indeed the whole experience of computing becomes one of building objects that of course persist and seem &#147;alive.&#148; Rather than writing recipes that only temporarily instantiate objects, you create them directly, knowing that they will be there for you later.

Changed lines 83-86 from:
The class will have regular weekly assignments, which will be graded and returned.  Cumulatively these assignments are worth 25% of your overall grade.  Assignments will be accepted up to 1 week late with a 50% reduction in that assignment's value.  If you fall behind on your homework, it is much better to cut your losses and work on the current assignment, instead of running behind trying to catch up.

There will be two in-class quizzes during the semester.  Each is worth 10% of your overall grade.
to:
The class will have regular weekly assignments, which will be graded and returned.  Cumulatively these assignments are worth 50% of your overall grade.  Assignments will be accepted up to 1 week late with a 50% reduction in that assignment's value.  If you fall behind on your homework, it is much better to cut your losses and work on the current assignment, instead of running behind trying to catch up.

There will be two in-class exams during the semester.  Each is worth 10% of your overall grade.

''Note:''
->I am aware it is a good teaching practice to announce when the in-class exams will occur on the first day of class. I apologize that I am not doing this. It's primarily because I prefer to schedule these exams when I am away, and I'm not sure of those dates now. I will make sure to give you two weeks' notice for all in-class exames
.
Changed lines 94-101 from:
You may notice that this leaves 25% remaining. Based on last semester's success, I am continuing with a course final project, which will be conducted in the last three weeks of the semester.  We will exploratory research and discussions before then, though, so you can start preparing for it.

In the final project, you will apply the ideas developed in the class in an original software implementation. You may thus connect the ideas of the class with your own interests&#151;music, robotics, art, databases, the web, networking, gaming, etc. The learning goal of the project is to have you find some real-world relevance of the ideas in the class.

To summarize:

25% Weekly homeworks \\
20% Two quizzes
\\
to:
50% Weekly homeworks \\
10% Two exams
\\
Deleted line 96:
25% Project \\
Added lines 37-84:

So, what will be doing in my class this semester?

* We will definitely be writing lots of code
* We will be doing it in C++
* We will be using some pretty cool APIs, including [[SFML->http://sfml-dev.org]], a free, open-source &#147;simple fast media library&#147; for C++, which is available for Mac, Win, and Linux (translation: it's a gaming library)
* Best of all, we'll be working through some awesome problem sets developed over the last 15 years at Princeton by Robert Sedgewick.

The Princeton stuff is great because it's all about how computing connects to the larger world.

It's not the usual stuff about using computing to do ever-more complicated things. This is necessary and valuable, but it's kind of self-referential and insular. Dare I say, incenstuous.

Here are some of things we'll be doing:

* Using Newton's laws of planetary motion and the &#147;leapfrog finite difference approximation&#148; method (don't worry; it's not hard) to create a totally realistic simulation of our solar system&#151;complete with live animation

* DNA analysis techniques widely used in bioinformatics, based on the concept of comparing sequence-strings on their &#147;edit distance&#148;

* Cryptographic techniques using a linear feedback shift register&#151;including encoding and decoding an image

* Simulating the vibration of a guitar string, with a thing called the &#147;Karplus-Strong algorithm (also not too bad). This will include generating actual audio files and listening to them

Also in a partnership with [[Kronos->http://www.kronos.com/]], a Chelmsford, MA-based company which happens to be the largest employer of software developers that has its headquarters in MA:

* Techniques for parsing 0.5 MB error logs generated by failed InTouch devices, their hardware time-clock unit. Note: these are not neatly well-formed like proper XML!

Based on the historical role of the course in UMass Lowell's computer science curriculum, and my hopes/plans for the semester, I'd like to predict the following learning outcomes:

* You will become much more comfortable writing C++ code and using object-oriented methods.
* You will gain experience architecting solutions to reasonably well-structured problems.
* You will learn how to use some great C++ APIs (not only SFML, but Boost&#151;by the way, we're going to be doing some unit testing stuff).
* You'll gain practice with the most important thing about documentation, which is: Naming. Stuff. Well.

Collectively, these things represent to me what is the most important learning outcome of the course, which is you progressing down your journey of becoming an effective and confident software engineer.

Also, I won't be teaching you to use an IDE. You are welcome to use your favorite one, but I won't be requiring their use nor teaching about them. I do hope you all share your favorite environments with each other. When I do stuff with you in class, you'll be seeing Emacs, the Unix shell, and Makefiles.

Also #2, you're welcome to use your favorite platform (as long as it is one of Linux, Mac OS X, or Windows).
* I'll be using Linux. If you don't have a strong preference you should choose that.
* I can provide you with some help for Mac, as long as you're not using Xcode.
* If you're on Windows, that's fine, but you'll need to turn to your classmates for support.

OK, that's the course overview! Now on to some more tactical things.




Changed lines 26-29 from:
* Prof. Xinwen Fu teaches principles of computer vision and practical applications using OpenCV
* Prof. Jesse Heines teaches XML parsing and related material
* (former UML) Prof
. Li Xu taught a 6-week module on compiler design (see http://dl.acm.org/citation.cfm?id=1121370)
* Prof
. Bill Moloney used to teach how to build a calculator using Lex and Yacc (i.e., parsing and grammars)&#151;see https://web.archive.org/web/20010803022749/http://www.cs.uml.edu/~bill/cs204/
to:
* Prof. Xinwen Fu teaches principles of [[computer vision and practical applications using OpenCV->http://www.cs.uml.edu/~xinwenfu/Classes/91.204.201/91.204.201_Syllabus_SP2013.htm]]
* Prof. Jesse Heines teaches [[XML parsing and language processing->http://abraham
.cs.uml.edu/~heines/91.204/91.204-2012-13f/classnotes.jsp]]
* (former UML) Prof
. Li Xu taught [[a 6-week module on compiler design->http://dl.acm.org/citation.cfm?id=1121370)]]
* Prof. Bill Moloney used to teach [[how to build a calculator using Lex and Yacc (i.e., parsing and grammars)->https://web.archive.org/web/20010803022749/http://www.cs.uml.edu/~bill/cs204/]]
Added lines 33-36:

I'd also say that there definitely existed a point in time when having all students learn how to write a linker was absolutely the correct answer.

Now in Spring 2014 though, the course is an oddball in that it's required, but it's allowed to vary a lot based on instructor interests.
Deleted line 25:
* (former UML) Prof. Li Xu taught a 6-week module on compiler design (see http://dl.acm.org/citation.cfm?id=1121370)
Changed lines 28-37 from:

Probably the only thing that can strongly be claimed about the course throughout the years is &#146;do stuff in C++, &#147; &#146;have the students write lots of code,&#147; and &#146;do cool stuff.&#147;

We will be using the following book
:

'''Structure and Interpretation of Computer Programs''' (2nd edition, 1996, ISBN 0070004846) [[<<]] Hal Abelson and Jerry Sussman [[<<]] %height=150px% [[http://mitpress.mit.edu/sicp/ | Attach:scip-cover.jpg]] [[<<]]
The Abelson/Sussman book is available online (for free) [[http://mitpress.mit.edu/sicp/ | here]].  If you like holding a book in your hands, used hard copies are available between $30 and $40.  Make sure to get the 2nd edition, published in 1996
.  Here are links: ''[[http://uber-bot.bigwords.com/details/book/Structure_and_Interpretation_of_Computer_Programs_Second_Edition/9780070004849/0070004846|bigwords]]'', ''[[http://www.alibris.com/booksearch?qwork=10662926|alibris]]'', ''[[http://www.amazon.com/Structure-Interpretation-Computer-Programs-Second/dp/0070004846/|amazon]]'', ''[[http://www.bookfinder.com/search/?author=&title=&lang=en&isbn=0070004846&submit=Begin+search&new_used=*&destination=us&currency=USD&st=sr&ac=qr|bookfinder]]''


Basically all departments that award bachelor's degrees in Computer Science have a course like OPL.  Such a class is also required by CSAB, the professional organization that accredits CS degrees.  So, everyone's got one&#151;why?
to:
* (former UML) Prof. Li Xu taught a 6-week module on compiler design (see http://dl.acm.org/citation.cfm?id=1121370)
* Prof. Bill Moloney used to teach how to build a calculator using Lex
and Yacc (i.e., parsing and grammars)&#151;see https://web.archive.org/web/20010803022749/http://www.cs.uml.edu/~bill/cs204/
* Prof. Emeritus Bob Lechner says the course used to be about building a linker (personal conversation)

Probably the only thing that can strongly be claimed about the course throughout the years is &#147;do stuff in C++, &#148; &#147;have the students write lots of code,&#148; and &#147;do cool stuff.&#148; (Of course, this last one depends on one's definition of cool
.)


Changed lines 8-10 from:
According to the [[http://www.uml.edu/Catalog/Courses/undergraduate/91-204.aspx|catalog]], 91.204 Computing IV is...

->Development of large software projects. Software engineering principles and practice. Object-oriented analysis and design. CASE productivity aids. Development techniques for program-translation software and web software.
to:
!!Text

We will not use a textbook.

Materials for this course will provided on this site and in links to other sites.

!!Rationale

As of Spring 2014, the catalog listing for  91.204 Computing IV [[http://www.uml.edu/Catalog/Courses/undergraduate/91-204.aspx|says]]:

->Development of large software projects. Software engineering principles and practice. Object-oriented analysis and design. CASE productivity aids. Development techniques for program-translation software and web software.

This is old, and we'll be shortly revising it to something more like:

->Advanced C++ programming, which deepens studentsí understanding of object-oriented analysis and design. Basic software engineering principles and practice, including documentation standards. Principles of large software projects, including work with APIs. Topics may include program translation, web software, parsing, and regular expressions.

But even this doesn't tell the whole story, because various faculty who have taught / are teaching the course do very different things:

* (former UML) Prof. Li Xu taught a 6-week module on compiler design (see http://dl.acm.org/citation.cfm?id=1121370)
* Prof. Xinwen Fu teaches principles of computer vision and practical applications using OpenCV
* Prof. Jesse Heines teaches XML parsing and related material

Probably the only thing that can strongly be claimed about the course throughout the years is &#146;do stuff in C++, &#147; &#146;have the students write lots of code,&#147; and &#146;do cool stuff.&#147;

We will be using the following book:

'''Structure and Interpretation of Computer Programs''' (2nd edition, 1996, ISBN 0070004846) [[<<]] Hal Abelson and Jerry Sussman [[<<]] %height=150px% [[http://mitpress.mit.edu/sicp/ | Attach:scip-cover.jpg]] [[<<]]
The Abelson/Sussman book is available online (for free) [[http://mitpress.mit.edu/sicp/ | here]].  If you like holding a book in your hands, used hard copies are available between $30 and $40.  Make sure to get the 2nd edition, published in 1996.  Here are links: ''[[http://uber-bot.bigwords.com/details/book/Structure_and_Interpretation_of_Computer_Programs_Second_Edition/9780070004849/0070004846|bigwords]]'', ''[[http://www.alibris.com/booksearch?qwork=10662926|alibris]]'', ''[[http://www.amazon.com/Structure-Interpretation-Computer-Programs-Second/dp/0070004846/|amazon]]'', ''[[http://www.bookfinder.com/search/?author=&title=&lang=en&isbn=0070004846&submit=Begin+search&new_used=*&destination=us&currency=USD&st=sr&ac=qr|bookfinder]]''


Basically all departments that award bachelor's degrees in Computer Science have a course like OPL.  Such a class is also required by CSAB, the professional organization that accredits CS degrees.  So, everyone's got one&#151;why?

In my opinion, this course exists to give you a different way of thinking about computing.  A way that is really quite apart from the &#147;professional&#148; programming languages like C, C++, and Java, all of which are based on an edit/compile/debug/deploy model of computation.

There are basically two variants of the OPL-type course at CS departments.  One variant is a survey of the ideas in many languages that have been created and implemented.  The other variant is a deep-dive into a language favored by language researchers, often Scheme or CAML.  Both of these languages are &#147;meta-languages&#148;&#151;they are languages for making languages.

At UMass Lowell, we take the 2nd approach (deep dive) in our undergrad course, and the survey approach in our grad class.  For many years here, 91.301 has been a close implementation of the famous &#147;6.001&#148; course at MIT, ''Structure and Interpretation of Computer Programs.'' This course was created in the 1970s and has been hugely influential. 

Now, it so happens that MIT has just implemented a major overhaul of their undergrad EECS curriculum, and as of Fall 2008, the 6.001 course is no longer being offered. Given that, why are we still teaching it, you might ask?

!!Isn&#146;t Scheme a Dead Language? (aka, Why do I have to take this class?)

Scheme isn't exactly dead.  There is a committed community involved in on-going development of the version of Scheme we'll be using (Racket).  Scheme itself is a streamlined, pedagogically pure version of Lisp; Lisp is an expanded version of the language, with lots of libraries useful in real-world applications.  While not hugely popular, there are still significant real-world systems being built in Lisp.  The [[Attach:itastory.pdf|Orbitz flight reservation system]] is a leading example.

More importantly, the ''ideas behind Scheme''&#151;e.g., functional programming&#151;are valuable, even if you're not coding in Scheme. 

* Jane St. Capital, a Wall Street trading company, does a lot of programming in OCaml, and object-oriented functional programming language, and explicitly recruits Scheme programmers. (See their research paper at http://portal.acm.org/citation.cfm?id=1394798).

* It is now clear that processors aren't going to be getting faster at the rate they have been over the last 20 years, and that multi-core systems and their associated programming will be increasingly important in order to continue the performance gains we expect.  Functional programming is much easier to parallelize than traditional imperative styles, and many believe that expertise in thinking in functional ways is becoming more and more important.  See the recent Dr. Dobbs article, &#147;[[Attach:Dr_Dobbs_It_s_Time_to_Get_Good_at_Functional_Programming.pdf|It's Time to Get Good at Functional Programming.]]&#148;

* Many languages, including C++, now incorporate ideas that originated in Lisp/Scheme, including closures and anonymous functions.

* Aside from the particular concepts in Scheme or Lisp, they represent a fundamentally different approach to building languages than the dominant method, which is based on compilers and binary executables.  Scheme and Lisp are implemented as interpreters, and interpreters allow a much more iterative and interactive style of code development.  Python is the presently the most popular language that is based on the interpreter approach.  Also, interpreters are often built into domain-specific applications as powerful, accessible scripting environments within those applications; Tcl and [[Lua->http://en.wikipedia.org/wiki/Lua_(programming_language)]] are other languages often built into systems as interpreters.  [[AutoCAD->http://en.wikipedia.org/wiki/AutoLISP]] and [[GIMP->http://www.gimp.org/tutorials/Basic_Scheme/]] are two well-known systems that include Lisp or Scheme interpreters.

!!What Is The Big Idea Then?

There are actually several &#147;big ideas&#147; that we will bring out in OPL:

* '''Program-as-data.'''  In typical programming languages, there is a sharp distinction between what is code and what is data.  Data structures are allocated explicitly, and code is written to manipulate them.  The two things are of a different nature.  (Of course, &#147;bits are bits,&#148; but you're not going to be placing executable code into an array unless you're implementing a buffer overrun attack.) 

->But in Scheme, the fundamental notation for describing code and data (known as the ''S-expression'') is the same thing.  Data structures and executable procedures are both nested lists.  Furthermore, it is commonplace for code to produce data that is executed as code. 

->This leads to the next point...

* '''Functions as first-class objects.''' In Scheme, procedures (also known as functions) can accept procedures as inputs (arguments).  But they also can easily create procedures as outputs (return values).  This leads to a style of programming known as ''functional programming,'' in which functions are composed and applied to lists of data to produce results, instead of the more prevalent approach of sequentially manipulating data structures.

->Please don't confuse C/Java functions with Scheme-style functional programming.  In C and Java, functions are really ''imperative'' programming&#151;a series of commands&#151;with lots of side-effects (mutation of data structures and variable values).  In functional programming, given the same input, the result of evaluating a function is always the same (think mathematical functions).  There is no global or external state that gets involved. 

->Functional programming has some advantages in transparency and simplicity, particularly in language and symbolic processing, and is facilitated by a language like Scheme in which code can easily construct and output code on the fly.  Also, a functional program, with its lack of side-effects and mutation of data structures, is much easier to parallelize&#151;you can run multiple functions separately and concurrently, without worrying about them fighting over the same shared data structures.

* '''Data abstraction.'''  This was one of the really big contributions of SICP&#151;the idea of abstracting data structures from the interfaces for manipulating them.  It then becomes possible to re-implement an underlying data structure without changing the code that uses it.  For example, if there is a @@concatenate@@ operation that appends one string to another, code that uses @@concatenate@@ doesn't need to change even if the underlying representation of a string changes.

->This idea, which is of course the basis of object-oriented programming, is so well-established that it may now seem obvious. But this was hardly the case in the 1960s and 1970s when SICP was developed.  Scheme has a somewhat different way of bundling together data representations and the procedures (methods) for manipulating them, which allows a high degree of flexibility.

* '''The environment and persistence.''' In typical programming environments, data and objects are created anew each time the program launches.  If you need to return to a previous execution state, then you read in data (e.g., from files on the disk or off the net) and reconstitute the data structures that hold that data.  Object-oriented languages typically provide some way to serialize objects&#151;converting them into a flat-file format (e.g., XML) for saving and loading across execution runs.

->Scheme handles things totally differently.  Once you create an object, it's just there&#151;existing in the environment in which it was created.  As long has you have a &#147;handle&#148; to it (i.e., you've named it, or it's part of another object that you have access to), the object will persist.  When you quit Scheme, the entire environment including all objects gets saved to disk.  Next time you relaunch, you reload the environment file and everything is exactly as you left it.  (There once were Lisp Machines, and the concept of &#147;quitting Scheme&#148; didn't exist.)  Smalltalk, the language developed by Alan Kay as part of the [[Xerox Star project->http://en.wikipedia.org/wiki/Xerox_Star]] [a.k.a., the machine that led to the Macintosh and the WIMP windows-icon-mouse-pointer interface], also implemented code and data persistence through a [[saveable environment image->http://en.wikipedia.org/wiki/Smalltalk#Image-based_persistence]].  In fact, [[Squeak->http://www.squeak.org/]], a current implementation of Smalltalk, includes code and data objects that were created back in the 1970s during the original Smalltalk work&#151;as a &#147;sourdough yeast starter&#148; reproduces itself through the years.

->As part of the implementation of the environment, garbage collection was introduced.  Objects that had no way of being accessed (i.e., they had no names, no pointers to them) could be removed from memory, and the space they took up could then be freed for other purposes.  Once controversial because of its complexity, automatic garbage collection is now considered an obvious part of a modern language design.

* '''Interpretation and the Listener.''' Scheme was historically an interpreted language, and provided a &#147;Listener&#148; console for interactively constructing expressions and evaluating them.  (At one time, the fact that it was interpreted was considered a significant performance liability, but compiled versions of Scheme and Lisp now exist, removing this as a concern.) 

->Because of the Listener, developing Scheme programs feels quite different than working in a typical edit-compile-test language.  After a single procedure is defined, you can try it out interactively, giving it inputs and examining its outputs.  Combined with the concept of the environment, you end up iteratively and alternately developing data structures and the code for operating on them.

->When you become accustomed to the Listener, you feel stymied without it.  It becomes annoying to write @@main@@ functions simply for the purpose of exercising your routines&#151;why can't you just talk to them directly?  Similarly, the environment is a powerful construct&#151;you build up a library of objects that are part of your project, and once created, they are part of your software system.

->Indeed the whole experience of computing becomes one of building objects that of course persist and seem &#147;alive.&#148; Rather than writing recipes that only temporarily instantiate objects, you create them directly, knowing that they will be there for you later.

!!Course Structure and Grading

The class will have regular weekly assignments, which will be graded and returned.  Cumulatively these assignments are worth 25% of your overall grade.  Assignments will be accepted up to 1 week late with a 50% reduction in that assignment's value.  If you fall behind on your homework, it is much better to cut your losses and work on the current assignment, instead of running behind trying to catch up.

There will be two in-class quizzes during the semester.  Each is worth 10% of your overall grade.

There will be a cumulative final, worth 20% of your overall grade.

Classroom participation is worth 10% of your overall grade.  In practice, if your other grades put you on a marking boundary, this will push it one way or the other.

You may notice that this leaves 25% remaining. Based on last semester's success, I am continuing with a course final project, which will be conducted in the last three weeks of the semester.  We will exploratory research and discussions before then, though, so you can start preparing for it.

In the final project, you will apply the ideas developed in the class in an original software implementation. You may thus connect the ideas of the class with your own interests&#151;music, robotics, art, databases, the web, networking, gaming, etc. The learning goal of the project is to have you find some real-world relevance of the ideas in the class.

To summarize:

25% Weekly homeworks \\
20% Two quizzes \\
20% Final \\
25% Project \\
10% Classroom participation \\

!!Discussion Group / E-Mail List

We will use Google Groups for class conversation and announcements.  Please join this group.  I'd advise setting your preferences to immediate, individual delivery of messages&#151;click the &#147;Edit my membership&#148; tab.

(:html:)
<table style="border:1px solid #aa0033; font-size:small" align=center>
  <tr>
    <td rowspan=3>
    <img src="http://www.cs.uml.edu/ecg/uploads/OPLspr14/googlegroups_logo.gif" height=58 width=150 alt="Google Groups">
    </td>
    <td colspan=2 align=center><b>Subscribe to 91301-s14</b></td>
  </tr>
  <form action="http://groups.google.com/group/91301-s14/boxsubscribe">
  <tr>
    <td>Email: <input type=text name=email></td>
    <td>
      <table
      style="background-color:#ffcc33;padding:2px;border:2px outset #ffcc33;">
      <tr>
        <td>
        <input type=submit name="sub" value="Request">
        </td>
      </tr>
      </table>
    </td>
  </tr>
  </form>
  <tr><td colspan=2 align=center>
  <a href="http://groups.google.com/group/91301-s14" target="new">Browse Archives</a>
  </td></tr>
</table>
(:htmlend:)

The group address is mailto:91301-s14@googlegroups.com.  You have to be a member to send to the list.

!!Collaboration Policy

You are welcome to discuss ideas in the class with your peers.  However, pair programming or other sharing of code is not allowed.  By turning in an assignment, you attest that ''you have written'' the code that it includes. Please be familiar with the university's [[academic integrity policy->http://www.uml.edu/catalog/undergraduate/policies/academic_dishonesty.htm]].

!!Honors Section

Students who are registered for the honors section of the class are expected to have exemplary work, including classroom participation, written work, and the course project. Additional and more difficult problems will be assigned in most of the weekly problem sets.

!!Acknowledgment

Much of this course design is based on work done by UML Prof. Holly Yanco.
Changed line 6 from:
Mon/Wed/Fri, 10a &#150; 10:50a, Room TBA
to:
Mon/Wed/Fri, 10a &#150; 10:50a, OS402
Changed line 1 from:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[Project]] [[https://groups.google.com/forum/#!forum/91-204-202-s14 | Discussion Group]]
to:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[https://groups.google.com/forum/#!forum/91-204-202-s14 | Discussion Group]]
January 16, 2014, at 03:56 PM by Fred G Martin -
Changed lines 6-10 from:
Mon/Wed/Fri, 10a &#150; 10:50a, Room TBA
to:
Mon/Wed/Fri, 10a &#150; 10:50a, Room TBA

According to the [[http://www.uml.edu/Catalog/Courses/undergraduate/91-204.aspx|catalog]], 91.204 Computing IV is...

->Development of large software projects. Software engineering principles and practice. Object-oriented analysis and design. CASE productivity aids. Development techniques for program-translation software and web software.
January 16, 2014, at 03:48 PM by Fred G Martin -
Changed lines 1-2 from:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[Project]] [[http://groups.google.com/group/91204202-s14 | Discussion Group]]
to:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[Project]] [[https://groups.google.com/forum/#!forum/91-204-202-s14 | Discussion Group]]
Changed line 6 from:
Mon/Wed/Fri, 10a &#150; 10:50a, Room TBA
to:
Mon/Wed/Fri, 10a &#150; 10:50a, Room TBA
January 16, 2014, at 03:47 PM by Fred G Martin -
Changed lines 1-3 from:
Computing IV home page

MWF 10a
to:
[[Comp4spr14|Home]] [[Assignments]] [[Lecture Blog]] [[Resources]] [[Project]] [[http://groups.google.com/group/91204202-s14 | Discussion Group]]

91.204.202 Computing IV, Spring 2014 \\
'''Prof. Fred Martin''', (:html:)<a href="http://mailhide.recaptcha.net/d?k=01COSqrfJ-58cc94fQb2pI1A==&c=iZBP8kCznrjdnfw8QFFKADFtsIimnLdVHk581djoISQ=" onclick="window.open('http://mailhide.recaptcha.net/d?k=01COSqrfJ-58cc94fQb2pI1A==&c=iZBP8kCznrjdnfw8QFFKADFtsIimnLdVHk581djoISQ=', '', 'toolbar=0,scrollbars=0,location=0,statusbar=0, menubar=0,resizable=0,width=500,height=300'); return false;" title="Reveal this e-mail address">click for fred's email</a>(:htmlend:) \\
TA:  TBA \\
Mon/Wed/Fri, 10a &#150; 10:50a, Room TBA
January 16, 2014, at 03:42 PM by Fred G Martin -
Changed lines 1-3 from:
Computing IV home page
to:
Computing IV home page

MWF 10a
January 15, 2014, at 10:15 PM by Fred G Martin -
Added line 1:
Computing IV home page
Edit - History - Print - Recent Changes - Search
Page last modified on April 12, 2014, at 12:18 PM