On this page:
Software Development

Software Development

Software Development

I expect students to visit this page once per 24 hours starting with the first day of the semester.



Tue Dec 18 10:25:31 EST 2018

The End

Dear Software Dev Fall ’18 students,

here are some end notes on this instance of the course.

For those who live for statistics and comparative grades, here are some basic numbers:

average score



median score



median grade



A level



B level



C level






As mentioned in Week 14 Memo Inspection Results, we did not subtract any points for content but we did take note of it. What struck me personally is that many of your final memos lacked any critical reflection on your chosen language. As the test fests and the final code walks amply demonstrated, all languages (and IDEs) let you down in one way or another (mine, too).

Let me list three (anonymized), positive examples here that demonstrate how reflective programmers notice problems with their programming languages (and IDEs):
  • A pair that had to switch from one uncommon language to another noticed how they “experienced a marked reduction in development hours immediately upon switching from Language1 to Language2. This reduction in labor was also accompanied by an increase in unit tests” despite some issues with the new language and its IDE.

  • Another pair admitted that their work with an extremely popular language suffered from “dynamic typing, a JSON standard library that could not parse multi-line JSON, loading modules via file paths, and TCP connection handling.”

  • Finally, here is precise analysis of how the lack of static type checking can affect a developer’s work:

    This flexibility required a disciplined focus on good design. XYZ’s untyped nature made it very easy to be fluid with data definitions and signatures. In particular, any change to a data definition was incredibly easy to do locally, but very difficult to guarantee globally. ... Tracking down every line of code affected by such changes quickly became a nightmare, because execution could fail silently in any number of ways.

To reach this level of maturity takes reflection and experience (with several different programming languages). The best developers have both and, from what I can tell, they truly enjoy their work because of this.

Lastly, I would like to illustrate a wide spread problem with a quote from a memo:

Another issue we encountered with [language XYZ] was our unfamiliarity with its mutability rules. Specifically, when a variable x is assigned, appended, or otherwise added to another variable of mutable data type, any changes to x will also be reflected in variable y.”

What this passage and similar ones suggest is that some/many of you fail to understand that our basic courses teach concepts that apply to basically all languages. The authors of the above quote specifically fail to remember the aliasing concept, which is extensively covered as soon as mutation is introduced in Fundamentals II—in Java but it shows up in all modern languages. To become a successful software developer, you must free yourself from focus on syntax (superficial appearances) and learn to understand and adapt semantic concepts (true meaning of things).

With that said, I wish you all the best for the next semester and your software careers – Matthias Felleisen

Sun Dec 9 16:24:13 EST 2018

This month’s New Yorker tells the story of a huge success of pair programming (PDF) at Google. (While the New Yorker’s style might not be yours—it isn’t mine—it is a "good thing" (tm) to keep such stories around for when your colleagues or manager questions pair programming. Different takes appeal to different people.)

Wed Dec 5 19:20:39 EST 2018

Here are the final instructions to prepare your configurations:
  • Point your clients to antarctica.ccs.neu.edu. Use port
    • 55556 if you are in Matthias’s section

    • 55559 if you are in Jason’s section

  • You will run your server on login-students using the above ports to receive incoming messages. Make sure your code base is updated and runnable on this machine prior to your code walk.

Wed Dec 5 19:19:31 EST 2018 Wed Dec 5 11:58:31 EST 2018

We graded the lab books on the ok+-etc scale. The revised script below reflects this choice.

Here is how we will calculate the final grade:
#lang typed/racket
(define-type Projects      (Pair Natural [Listof Assignment]))
(define-type Assignment    (Pair Natural Natural))
(define-type Presentations [Listof OK])
(define-type Panels        [Listof OK])
(define-type LabBooks      [List OK OK])
(define-type Percent       Real) ; between 0.0 and 1.0
(define-type OK            (U 'ok+ 'ok 'ok- 'zero))
(define (% {x : Real}) (/ x 100))
(define PROJECT      (% 50))
(define PRESENTATION (% 20))
(define PANEL        (% 20))
(define LAB          (% 9))
(define FINAL        (% 20))
(define ASSIGNMENTS  (% 80))
[define ok+  (% 99)]
[define ok   (% 91)]
[define ok-  (% 82)]
[define zero (% 53)]
; The Perfect Student
(: perfect-projects Projects)
(define perfect-projects (cons 100 (list (cons 100 100))))
(define perfect-presentations '(ok+ ok+))
(define value-presentations (/ (+ ok+ ok+) 2))
(define perfect-panels '(ok+ ok+ ok+))
(define value-panels (/ (+ ok+ ok+ ok+) 3))
(: perfect-labs LabBooks)
(define perfect-labs '(ok+ ok+))
(define perfect-grade
  (+ (* 1/2 1.0)
     (* 1/5 value-presentations)
     (* 1/5 value-panels)
     (* 9/100 1.0)
     (% 1)))
(: final-grade (Projects Presentations Panels LabBooks -> Percent))
(define (final-grade projects presentations panels labs)
  (+ (* PROJECT      (project-grade projects))
     (* PRESENTATION (presentation-grade presentations))
     (* PANEL        (panel-grade panels))
     (* LAB          (lab-book-grade labs))
     (% 1))) ; instructors' whim
(: project-grade (Projects -> Percent))
(define (project-grade projects)
  (match-define (cons final-code-walk assignments) projects)
  (+ (* FINAL       (% final-code-walk))
     (* ASSIGNMENTS (assignment-grades assignments))))
(: assignment-grades (-> [Listof Assignment] Percent))
(define (assignment-grades grades)
  (define-values (student-score max-score)
    (for/fold : (values Real Real)
      ([student-score 0][max-score 0])
      ([g : Assignment grades])
      ;  IN
      (match-define (cons student max) g)
      (values (+ student-score student) (+ max-score max))))
  (/ student-score max-score))
(: okay-grades (-> [Listof OK] Percent))
(define (okay-grades oks)
  (/ (for/sum : Percent ((o : OK oks)) (grade-mapping o))
     (length oks)))
(: presentation-grade (Presentations -> Percent))
(define presentation-grade okay-grades)
(: panel-grade (Panels -> Percent))
(define panel-grade okay-grades)
(: lab-book-grade (LabBooks -> Percent))
(define (lab-book-grade labs)
  (match-define (list one two) labs)
  (/ (+ (grade-mapping one) (grade-mapping two)) 2))
(: grade-mapping (OK -> Percent))
(define (grade-mapping o)
    [(eq? o 'ok+) ok+]
    [(eq? o 'ok)  ok]
    [(eq? o 'ok-) ok-]
    [(eq? o 'zero) 0]
    [else (error 'grade-mapping "unreachable code")]))
(module+ test
  (require typed/rackunit)
   (final-grade perfect-projects perfect-presentations perfect-panels perfect-labs)

Tue Dec 4 12:51:02 EST 2018

Code Walk Preparation

For your final code walk, please prepare three plus one configurations for your client script:
  • the one requested via client-tests/1-in.json, if you didn’t do so already;

  • one that runs four fully functioning players that can survive a tournament;

  • one that runs two good players and two rule-breaking ones; and

  • one according to your own preferences (optional).

Place these additional configurations into 13/client-tests/. If you do not have suitable player implementations, do not prepare the corresponding tests. Just tell us so at the start of your session.

We will definitely ask you to run the first configuration, and we may get to others, depending on how much time it takes.

The two sections of the course will use different port numbers to experiment with these configurations. We will decide on those after confirming the subnet operations tomorrow.

Wed Nov 28 18:09:05 EST 2018

On Friday you must sign up in class for a slot for your final code walk. The final code walks will take place in WVH 166 and 168 on Thursday, 6 Dec.; Friday, 7 Dec.; and Monday, 10 Dec.

Tue Nov 27 09:07:00 EST 2018

News Flash Our customer has agreed to a 48 hour extension. 13 — Implementing Remote Proxies is now due midnight Wednesday, 28 Nov 2018.

Our team will also need to discuss how to interpret the print instructions for the tournament manager.

Sun Nov 25 17:25:44 EST 2018

At this point your repository should be organized as follows:


    +--+ Santorini

    |  |

    |  ...


    +--+ 1/





    +--+ 12off/


    +--+ 13

    |  |

    |  +--+ client-tests

    |  |  |

    |  |  +-- 1-in.json

    |  |  +-- 1-out.json

    |  |

    |  +-- server-tests

    |  |  |

    |  |  +-- 1-in.json

    |  |

    |  +-- xserver

    |  +-- xclients

The file server-tests/1-in.json is a server configuration, and it must have the following shape when we retrieve your solutions on Monday:


      "min players" : 3,

      "port"        : 55556,

      "waiting for" : 5,

      "repeat"      : 0


When your server terminates it, it must print the Results of the only tournament it ran.

The file client-tests/1-in.json must configure


     "players"   : [["good",     "foobar", ...],

                    ["infinite", "barfoo", ...],

                    ["infinite", "barfus", ...]],

     "observers" : [],

     "ip"        : "",

     "port"      : 55556


where you are free to choose any player names of course and the dots must be replaced with valid Linux paths to the dynamically loaded player configurations. To ensure that the players connect to the server in the specified order, your client script should pause for a second between each launch of a player.

The file client-tests/1-out.json must specify the Results of running a best-of-3 tournament of the first player against the second and the third and the second against the third—as appropriate.

The test fest will roughly correspond to the following Unix command line:

    $ ./xserver < server-tests/1-in.json | diff - client-tests/1-out.json &

    $ ./xclients < client-tests/1-in.json

While you should ensure that your pair of scripts behaves this way, keep in mind that the test fest will pair the staff’s server with your clients and vice versa.

Thu Nov 1 21:43:56 EDT 2018

We will collect the lab books in both sections tomorrow.

To make sure we get a full collection, we expect everybody to attend.

Sat Oct 27 18:58:43 EDT 2018

For all those of you who wish to become strong software developers, you may wish to scan Famous developers reveal the programming languages they’re glad they learned. One thing to notice is that "teenage heart-break languages" are not part of the chosen languages. Another one is that Norvig refers to modern Lisps, and you may wish to Google what he has said about Racket and HtDP. Finally, my own favorite answer is Marissa Mayer’s, but I will say I wouldn’t have recognized her as developer, only as a person whose name shows up on the business pages of newspapers.

Sat Oct 20 21:15:36 EDT 2018

You may wish to read up on the Windows development process (and weep).

And now to something different but somehow related: the gas explosion in Lawrence and why it happened and why it matters to future software engineers.

Fri Oct 5 18:03:39 EDT 2018

In case you didn’t see it yet, the results of test fests are available via the Projects, Specifics tab.

Fri Sep 21 17:56:41 EDT 2018

On the nature of this course and the remaining weeks

We have wrapped up the "warm up" part of the course, meaning the nature of the work and the workload will change dramatically.

For the first three weeks, you were asked to complete two radically different kinds of pieces of work:
  • explore your languageyou were asked to choose your favorite language because you should not feel that an instructor’s choice of language restricts you in any way. With this choice comes the obligation to explore the basic capabilities of your language: command line arguments, creating an "executable", standard input/output, TCP input/output, JSON (which is also your choice of data language) processing, and a few more small tidbits.

    Doing so is stressy. It is stressy because no course teaches such material and you have not had to do this kind of independent work before. It is stressy because we can’t support all the languages that you chose, meaning we cannot help anybody with language-specific hints. It is stressy because you need to cope with the consequences of your own choice.

    By now, you probably have a reasonable idea of what went wrong and what went well and how to improve what you have seen. So this form of stress will rapidly disappear.

  • designs small componentsyou were asked to design small components, stepping a little bit beyond what the three prerequisite courses drilled over and over again. Designing an interface really is a "large scale" version of the first three steps of the design recipe. Implementing an interface is learning to follow the last three steps, again in a new context.

    It is stressy to apply understanding in a context where nobody reminds you all the time about what you learned. It is stressy because you have to think hard how the lessons of the design process apply to your circumstance—even if the application turns out to be extremely direct.

And beyond all of this, you had to finish each assignment from one lecture to the next (because the lead instructor thinks that you can do it).

Going forward, the assignments will change in two ways:
  • you will get weekly assignments that will consist of two tasks: specify a component and implement my specification for another one, including an external test harness (standard input/output, JSON processing).

  • you will systematically scale up your understanding of the design process from Fundamentals I, II, and III to a reasonably large program and you will need to apply the idea of the design process in the context of your favorite language.

The workload will very much depend on your understanding of the design processes that you got to know (that’s not the grade you got in these courses, but what you understood) and your learning of how to apply these ideas in new contexts.

My experience with teaching a course like this suggests that you may end up spending as little as five+ hours on the implementation tasks or as much as forty+ hours. Non-systematic work is a large reason of why current software engineering practice often means working extremely long hours. Conversely a lot of the "process" related ideas (agile, TDD, etc) are attempts to inject some system with the goal of reducing the hours. The key to reducing the number of hours is to proceed as systematically as possible. This may sound counter-intuitive because many of you think that this means performing more work than a "hacking something together" approach—an intuition is both false and counter-productive because software systems are large artifacts whose pieces build on each other.

I hope this message will help you put work for Sw Dev into perspective.

Fri Sep 21 08:37:13 EDT 2018

Your test results and code-inspection grades for Week 3 Test Results are available.

Wed Sep 19 21:12:53 EDT 2018

For your amusement, a tweet from a former student.

(Dave is the former research CTO of Mozilla, a heavyweight behind the JavaScript standardization efforts and the mentor of the Rust project.)

Tue Sep 18 22:58:37 EDT 2018

Due to a miscommunication, we pushed the wrong protocol file into your repos’ directories named 4. Assignment 4 (4 — Implementing Protocols, Analyzing the Project) points to the correct one, and we have pushed a revised version by now. Apologies.

[For those who wish to know, I violated the "single point of control" policy and the two copies diverged. See "How to Design Programs" if "single point of control does not ring bells; part III in the second edition (p. 389).]

Mon Sep 17 13:00:13 EDT 2018

Given that there is some demand for more information on git usage, we will hold two recitation sections this coming Thursday:
  • Thursday Sep 20, 10:30am

  • Thursday Sep 20, 11:345m

Both will take place in 212 WVH. You do not have to be signed up for either of these specific sections to attend. Our goal is to use recitation slots extremely sparingly.

Sun Sep 16 14:01:90 EDT 2018

Your language/IDE memos are graded. I applied a simplistic grading scale. You could lose one point per each of the following criteria: file name (place), file format, margins, font size, TO, FROM, memo format, spellos, grammos, and content. For the last one, I used an extremely loose standard (organization, false statements, or completely unsupported claims) and losing points was rare. I did not reduce your score for stylistic faux pas.—Once the grades have been recorded, you will receive the memos from Ben and Sam in your respective sections.

I wrote a memo, too, and I urge you to scan it. The margin notes explain the organization and make a couple of sw dev points.

Sat Sep 15 19:30:34 EDT 2018

I have revised 3 — Exploring Your Favorite Programming Language Some More to relax some delivery constraints and to put your contribution in task 2 in context.

Wed Sep 12 19:45:19 EDT 2018

Systems informed me that their Linux image now comes with GHC Haskell v7.6.3, Rust v1.28, and Python v3.6.3 (python36). The old versions of Python are also available. They could not add Python v3.7 because CentOS (System’s choice of Linux) is not supported yet.

Tue Sep 11 22:02:43 EDT 2018

1. 2 — Exploring Your Favorite Programming Language specifies JSON as input. For you, you are guaranteed that your executable will be run on JSON values and you may crash for all other inputs.—In a robust system, your application will gracefully time out on bad inputs and eliminate the source.

2. A rectangular arrangement is a form of information. As Fundamentals I taught you (and Fundamentals II and OOD), you must pick a data representation from the data sub-language of your chosen language to get information like this into your language. And you must allow for ways to hand over such data to get build a "large" spreadsheet representation easily.

Mon Sep 10 17:41:12 EDT 2018

READMEyou do not need to set up a readme or a testme file until we start the project.

The "16pt baseline" requirement refers to the line spacing. Yes, this intentionally leaves little space for writing. Concise writing is good writing. Only (some) high school teachers reward you for writing a lot.

Wed Sep 5 09:12:57 EDT 2018

There will be no recitations until further notice.

Wed Aug 8 13:56:08 EDT 2018

Please reflect on all the programming languages you have experienced in the past and with which you would like to implement a serious project. Then pick your currently favorite language and make sure it is installed on your laptop. Bring a letter-size sheet with the name of your chosen language to the first lecture. Fold the sheet and place it front of you on the table in the classroom so that the instructor can see it.

Sun Apr 8 16:21:26 EDT 2018

Preliminary Web Site

This web site is preliminary. It is set up to assist people with choosing the section of Software Development that they wish to enroll in. Please read the Abstract to get an idea of how I run this course.

Hells Bells