Software Development

From the first day of the semester forward we expect students (you) to visit this page once per 24 hours.

Friday, December 18th, 2020 6:27:09pm

The End

Tuesday, December 15th, 2020 8:00:00am

The final grade script computes your final overall score. The type signature should compleyely explain its interpretation.

Thursday, December 10th, 2020 9:22:34am

The results for Milestone 10 are out. The scores range from 20 to 90 out of 120 base points. Keep in mind that we drop one homework score to maximize your average.

The more important part is what the scenario explanations mean. Less than half the test scenarios focus on tournaments with normal players. To start, for two scenarios, your clients connected to our server; they got 10s per call (more than 3x what was announced). They could not rely on the server running first. For eight scenarios, our clients connected to your server, meaning there was no time limit per call to be satisfied on your side (though we timed out after about 3 minutes per tournament). Most of our clients were broken and to be kicked. Their faults ranged from sending no name, a no-JSON name, ill-formed JSON, to invalid JSON; some also took a very long time to respond. As announced, the goal was to make sure your Remote/ code was robust and could withstand the most basic connection and I/O problems.

The final code walk does not depend on the correctness of the client-server. It is much more important that you can explain, and reason about, your design decisions with the two panelists.

Someone asked what an expected result of the shape  [[0, 4], [0, 3]] means? I had used the word "loser" in two different ways in the milestones: with a specific narrow meaning and its loose meaning in spoken English. Just in case anyone misinterpreted this meaning, I programmed the test harness to accept two solutions for this one case. In the example, it would accept either [0, 4] or [0, 3].

Thursday, December 10th, 2020 12:05:26pm

In case you didn’t catch the outcome of the vote during class, here we go ok+: 99, ok: 94, ok-: 88, zero: 61.

Monday, December 7th, 2020 6:41:59am

Voting The vote server is up. The revised vote announcement below includes a link to submission script. It runs at the command line on CCIS Linux and OS X as well as in DrRacket on Windows. The server will go down at 7:00pm.

Milestone 10 Modify your client to use exploration depth 1. Push this one-line fix by 7:00pm.

Lab Book Send your lab books to Ben Greenman. Use the following subject line: cs4500 lab book The deadline is also 7:00pm.

Final Code Walk Remember that as of 10:30am you can sign up for Final Code Walks.

Sunday, December 6th, 2020 9:10:24am

We will take down the server around 7pm the same day.

Fraud If we notice any attempt at fraud, vote harvesting, attack on the server, or discussions of the vote on-line (Piazza), we will void the election result. In this case, the instructors will assign four numbers to these grades.

Rationale As I explained in my section, voting serves two purposes. First, the evaluation of a presenter or a panelist is somewhat subjective even though we actually state and re-state our rubric during every post-mortem discussion of code walks. So we remedy this problem by giving students a voice. Second, it gives us, the instructors, a chance to meta-evaluate your skills of evaluating the performance of developers as presenters and panelists. Many of you will soon be in a position where you have to evaluate other developers, and you might as well reflect on this situation now.

Sunday, December 6th, 2020 7:13:16pm

Final Code Walks explains how to sign up for the final code walk as of tomorow, Monday 7 Dec 2020, 10:30am.

Wednesday, December 2nd, 2020 6:40:28pm

I have relaxed the implementatin for your server’s variant of take-turn. Implementing this via an adapater would might be too much work depending on your state representation. Thank you Julia for pointing this out.

Also, I have pushed a fuller explanation of the redundancy in the take-turn method call. See Remote Interactions.

Note My stress tests for the referee and tournament manager suggest that the imperative solution can be about 10-20% faster than the functional in plain cases. I therefore stopped using the imperative one, though my unit tests and contracts rigorously test that the two arguments are in sync.

Wednesday, December 2nd, 2020 6:05:15pm

The deadline for 10 — This is it! has been pushed back.

Monday, November 30th, 2020 10:41:33am

If you submitted a solution for 9 — The Humans, please make sure to sign up for a demo to make sure you get your credit. See your self-eval and Piazza.

Before you connect to your scheduled zoom session, log into a Linux server.

Saturday, November 21st, 2020 2:50:27pm

The actual test fest for 6 — Games! is complete now. The median for this part of the evaluation is 55 75 out of 70 base points.

Download the collected legal tests and work through your failures.

Wednesday, November 18th, 2020 1:15:54pm

The results for the code inspection of 7 — The Clean Up are out. The median is a 255 out of 250 base points.

Wednesday, November 18th, 2020 8:16:51am

Your main contractor has developed integration tests based on the specifications while you, the sub-contractor, worked on the code. Download to make sure the two parties agree on the most basic points of the software.

For the test fest, we will use 60s as the limit per game run.

Tuesday, November 17th, 2020 3:48:23pm

Friday, November 13th, 2020 9:12:09am

20 points out of 320? Really?

Q: Why did your software architect deduct 20 out of 320 base points from your latest "salary" for not using the game tree for rule enforcement?

A: Because he asked you to do so in 3 — The Game State. And he did so because he keeps in mind the socio-technical context of the project.

Q: Sure but why would we use a tree? Isn’t a rule book module more efficient?

A: Don’t forget the context of these calls. The referee will make function calls to the players via the network. That’s a far greater cost than any local call.

We could probably run a million linear-time checks for branching factors of 10 or 40 and the network traffic would still dominate.

Q: Okay, so a tree is less efficient than a rule book?

A: No. If efficiency refers to bigO time, a tree representation can use a hash map for the branches. The domain check is the legality check and basically constant.

But don’t forget the context.

Q: Fine but isn’t it true that a rule book makes for much more readable referee code? All my developer friends say so!

Rule Book Module

(take-turn (-> state? turn-action? (or/c state? #false)))

So in essence the referee is the same modulo the identifier tree vs state. Your software architect considers these two options equally readable. A name refactoring could make them even identical.

Q: Even if the referee modules are kind of the same, isn’t it so much simpler to construct the rule book module than the tree module?

A: If, and that’s if, you were working on Common/ and referee only, you could consider a tree "overkill". But again, remember the context.

We are implementing players for two reasons. First, we must test the logic of the entire system before we construct a communication layer. Second, our resident AI expert has called for the exploration of a classic AI strategy, the minimax optimization on the tree. So we have to design and implement the tree anyways; we might as well use it for action checking,

Q: Is it really worth 20 out of 320 points?

A: You’re right. For violating an explicit specification, your manager/architect should probably have deducted 40 points, not just 20. But 20 it is, and 20 it stays.

Friday, November 13th, 2020 5:53:27pm

The specifications of 8 — The League have been refined to eliminate some potential ambiguities.

Friday, November 13th, 2020 9:25:31am

Send your lab books to Ben Greenman.

Wednesday, November 11th, 2020 10:30:36am

Why Game Trees

I have spelled out the rationale below in my section several times, but code walks in all sections suggest, it is best to write this rational down once and for all.

Step 1: Rule Books Board games come with rule books, which are written in English. Everyone who has played a board game knows that different people interpret such rules in different ways, and people end up discussing interpretations during a game.

This kind of misinterpretation represents billions and trillions of dollars in the complex financial contracts that have been developed over the last three or four decades. See my thoughts on the SEC’s idea on Python for asset-backed securities.

Since Fish will ask people to pay money to participate in "hey that’s my fish" tournaments, we must publish the rules of the game. We could use English. And we would get sued about different interpretations, and it would then be likely that we will end up getting fined. Some jury somewhere will side with the participant.

In class I say Common/ represents the common ontology. As software developers, we have an obvious alternative to English: code. Instead of publishing the rules of the game in English only, we publish the code in Common/ and tell potential participants that "code rules." All they have to do is download it, read, and run the code. In case of a conflict we can point any jury to this code.

This strategy is effective only if the unpublished referee uses this rule book. If the referee re-implements the rule checking, any articulate expert will convince any jury that there is a conflict between the rule book and the referee’s re-implementation.

Step 2: Game Trees Using the game tree to represent the rule book is This choice roughly corresponds to the European idea of law as rules that govern all known and future situations in a uniform manner. overkill. In an ordinary situation, it would suffice to implement the following components: rule-book on top of game-state, knowledge-about-player, board, and tile.

But, a secondary requirement for any solid course on software development is the inclusion of one challenging milestone concerning data structures and algorithms. Ideally, this should involve "large data" or even a database.

Shortcomings You may argue that during the placement phase—or as our lectures call it, the system initialization phase—should be included in the rule book or should have a chapter of its own. That’s correct. We ignored this issue because (1) the enforcement is straightforward—there is a tile and there’s no penguin on the tile—and (2) it simplifies your implementation.

Monday, November 9th, 2020 4:25:31pm

Some of you have expressed unhappiness with the code base you have received. Here is how you may go about switching back to your own code base:

Sunday, November 8th, 2020 10:53:27pm

The actual test fest for 6 — Games! is complete now. The median for this part of the evaluation is 180 out of 140 base points. Congrats to everyone.

Download the collected legal tests and work through your failures.

Friday, November 6th, 2020 6:32:37am

ACM is hosting a tech talk on code reviews. Laurie Williams, the first researcher to study pair programming in depth (I have mentioned her in class a couple of times) will interview Michaela Greiler, an industry consultant who specializes in this area. If you have time, you may wish to tune in.

Thursday, November 5th, 2020 12:48:28pm

I have clarified some minor gaps between Fish and Fish.Com, a Plan. These clarifications will not affect your on-going projects, though they may affect the design and implementation of future components.

Wednesday, November 4th, 2020 12:36:47pm

Your main contractor has developed integration tests based on the specifications while you, the sub-contractor, worked on the code. Download to make sure the two parties agree on the most basic points of the software.

Tuesday, November 3rd, 2020 7:53:58am

The notion of State has been refined for the test cases of 6 — Games!.

Monday, November 2nd, 2020 8:12:39am

We re-ran the test fest for 5 — The Strategy to accommodate both legal and incomplete but potentially legal input states. This was done to eliminate an ambiguity between a piazza conversation and the web page. Many of your implementations cannot run such potentially legal tests, so they are not included in the bundle below.

The median for this part of the evaluation is 130 out of 140.

Download the collected legal tests and work through your failures.

Tuesday, October 27th, 2020 4:03:55pm

5 — The Strategy has been updated to eliminate the name "minimal maximum" for the algorithm you implement. The specification itself stands as is.

Friday, October 16th, 2020 9:22:42pm

NULL—Hoare’s billion dollar mistake

K. asked about Java’s optional type (in one of the more recent versions of the language). The idea is absolutely the correct one, and it has been around for approximately forever. The realization in the standard took a long time, and the interface is clumsy. Functional languages such as Haskell and Maybe and SML and option have done significantly better. Sadly, Java is often a compromise between what "old" people think programming should be and the designers and specifiers of the language who understand the language design research quite well.

Tuesday, October 27th, 2020 1:40:13pm

Saturday, October 24th, 2020 7:38:41pm

Jake H. discovered an ambiguity in the test task of 5 — The Strategy. This Saturday night revision resolves the ambiguity.

Wednesday, October 21st, 2020 4:26:34pm

Based on observations from my TAs, I have clarified the two "functionality bullets" in 4 — The Game Tree.

Tuesday, October 20th, 2020 1:18:29pm

See 4 — The Game Tree for a revision of the deadline.

Thursday, October 15th, 2020 5:43:36pm

The following is a script that an experienced Racketeer would write with the principles of Fundamentals I in mind without writing down all pieces.

xcheck

#! /usr/bin/env racket -tm

#lang racket/base

;; Usage: run

;;   ./xcheck PathToSpecification

;; at the top-level of a repo. It checks whether the repo is organized

;; according to the Spec found in PathToSpecification.

#; {type Spec = Symbol u .* u [** Symbol] u [Cons Symbol [Listof Spec]]}

;; Symbol is a name, .* means "any file", [** Symbol] means optional;

;; (S . Spec) is the specification for sub-directory S

(provide main #;{PathString to Specification of required file/dir org})

(require racket/match racket/set racket/format)

(define (main lvl) (check-spec (with-input-from-file lvl read)))

#; {Spec -> Void}

(define (check-spec sp [path "."])

(define-values (must may) (level->set sp))

(check-1-level (member '|.*| sp) must may path)

(define dirs

(for/list ([l sp] #:when (and (pair? l) (set-member? must (~n (car l)))))

l))

(for* ([m dirs][dir (in-value (~n (car m)))])

(when (directory-exists? dir)

(parameterize ((current-directory dir))

(check-spec (cdr m) (~a path "/" dir))))))

#; {Boolean [Setof String] [Setof String] PathString -> Void}

(define (check-1-level any must may P)

(define all (map path->string (directory-list)))

(for ([m must] #:unless (matched? m all)) (displayln `[,m missing at ,P]))

(unless any (extras all (set-union must may) P)))

#; {[Listof String] [Listof String] PathString -> Void}

(define (extras F Pats Path)

(define (match-one f) (for/or ([p Pats]) (matched? p (list f))))

(define xtra (for/list ([f F] #:unless (match-one f)) f))

(when (pair? xtra) (displayln `[,xtra should not exist at ,Path])))

#;{Spec -> (values [Setof String] [Setof String])}

(define (level->set lvl)

(define-values (man opt)

(for/fold ([man '()][opt '()]) ([l lvl])

(match l

[`[** ,k]     (values man (cons (~n k) opt))]

[`[,d ,_ ...] (values (cons (~n d) man) opt)]

[_            (values (cons (~n l) man) opt)])))

(values (apply set man) (apply set opt)))

#; {String [Listof String] -> Boolean}

(define (matched? p all) (for/or ([a all]) (regexp-match p a)))

#; {Symbol -> String}

(define (~n s) (cond [(regexp-match "(.*)/" (~a s)) => cadr] [else (~a s)]))

Neither the script nor the spec are the ones we use for checking whether you can follow basic instructions.

Wednesday, October 14th, 2020 3:55:35pm

If the above diagram conflicts with the prose in the tabs on the left, the prose overrides the diagram.

Friday, October 16th, 2020 9:39:55am

Please take a look at a sample game state specification. Yours may differe and get full credit, but this one provodes full guidance and later explanation of the design rationale.

[My implementation deviates from this plan.]

Wednesday, October 14th, 2020 11:20:04am

—Test Me is in effect as of milestone 3.

Tuesday, October 13th, 2020 7:56:04pm

3 — The Game State has been updated to include a restriction on the size of test cases you may submit. You may consider this a validity constraint.

Sunday, October 11th, 2020 1:14:09pm

Important

The testing task for 3 — The Game State exposed a gap in the "common ontology" between our software components, specifically whether straight lines stop at holes in the board. The answer is yes.

I have clarified the testing task and Fish accordingly.

[ Since we are dealing with the board only, there really is no need to figure out where penguins are, which is only a part of the game state. ]

Saturday, October 10th, 2020 11:36:29am

The following piece of advice collects in one place a Piazza post from Friday 09 October.

No matter what you do, you need an explanation of representation and interpretation meaning answers to the questions "how do I represent an actual game board (information) in my chosen data representation" and "how do I construct a board from an instance of my chosen data representation."

If you can answer both of these questions, you have a data representation.

If you don’t do this you have "stuff", not accessible pieces of software.

Saturday, October 10th, 2020 8:01:17am

Remember to complete your self evaluation by tonight.

Friday, October 9th, 2020 5:29:45pm

• I have clarified the interpretation of the test harness inputs in 3 — The Game State.

• Make arrangements to meet your instructor if you wish to discuss how to improve your participation in presentations and panels.

• Think of your two or three presentations during the semester as dress rehearsals for the final code walk.

Tuesday, October 6th, 2020 9:04:18am

I have made some adjustments to 2 — The Game Pieces. See the strike-out and purple words. In particular, the “rendering” task could have been misunderstood as “render just one tile” [of the board] but it really meant render all all tiles [of the board].

Friday, October 2nd, 2020 5:27:18pm

Sometime in the next hour or so, a file named self-1.md will appear in your code repository in directory 1/. This is your first self-evaluation probe of the project. See —Code Grades for details.

Thursday, October 1st, 2020 9:18:28am

Industrial people are slowly recognizing the downside of ticket-driven software development. Considering reading the Jon Evans’s blog post to get a sense of what these people are getting at. As I said in class on Tuesday, tools are no panecea, but people tend to think of them as such. The effectiveness of tools depends on the users, and in the case of JIRA the project management people: some know how to use it properly and many act like sheep.

Academia cannot and must not teach tools. Our goal has to be to teach thinking instead and create reflective people and software developers.

Wednesday, September 30th, 2020 1:39:49pm

We have added a Online Reviews subsection to In-Class Reviews. Please take a look before Friday.

Thursday, September 24th, 2020 9:09:35pm

Send your lab books to the section TA now.

Saturday, September 19th, 2020 4:52:03pm

See Lectures for the videos for next week.

Also re-visit D — GUI if you had difficulties interacting with your GUI program on the Linux servers.

Friday, September 18th, 2020 4:07:23pm

On the lighter side After describing the circular sociology of “there can be only one JSON thing in a json file” or the imminent death of Fortran (see Psychology of Programming), JH in the 09:50am section sent me to

https://xkcd.com/978/

Enjoy. And don’t forget to read the ALT text.

Wednesday, September 16th, 2020 3:44:07pm

As of next Tuesday, we will test-run code walks. We will start with a a set of panelists code walking my solution to one of our assignments, then some of us will play panelists for code walking a pair from the class. Following those two, we will conduct a couple of more trial runs with both presenters and panelists drawn from the class.

Wednesday, September 16th, 2020 8:21:29am

Tuesday, September 15th, 2020 4:55:07pm

See Lectures for the next batch of videos.

The transformation of textual information into internal data is known as parsing, a technical problem that spawned an entire research area. Parsing is so complex, it should never be used in an introductory course but to this day, many such courses assign programs that read text, analyze it, and react to it—without proper support. Proper coverage is offered in Compilers and Theory, and these two course will help you design parsing programs properly.

At first glance, JSON is a simple notation for writing down information in terms of Booleans, Strings, Numbers, arrays of JSON expressions, and objects of JSON expressions. But, as it turns out, turning JSON information into internal data is a minefield; indeed, no two JSON parsers seem to accept the same JSON inputs.

You should keep this fact in mind for your upcoming co-op and future employment.

Finally, if you are interested in recent studies of negative feedback to workers, you may wish to read The Rare Worker Who Thrives on Negative Feedback [PDF].

Sunday, September 13th, 2020 3:34:05pm

Lectures lists the videos for lectures past and the next one (or two) coming up. Please take a look at the videos for 09/15.

Saturday, September 12th, 2020 12:20:43pm

Contrary to rumors, B — Command Line is a pair-programming assignment. Indeed, as you can imagine from the brief explanation in class, the actual effort is negligible. Any single person can probably finish the code in less than 15 minutes.

The actual purpose is two-fold: (1) to get to know your partner with a tiny on-line assignment, and (2) to learn to live up very rudimentary specifications.

Note You were provided with email contacts, and some people may not read their emails on a daily basis, especially not over weekends. So, give your partner until Monday noon to get in touch with you, that is, reply to your first message. This deadline leaves you with 12 hours to finish something that ought to take 30 mins max in total.

If your partner does not reply to your emails by Monday noon, let your instructor know.

Wednesday, August 5th, 2020 9:46:03am

Welcome to the Fall 2020 issue of Software Development. As always, we aim to deliver a course that teaches you a lot, not in terms of industrial tools and techniques but for your life as a reflective software developer.

The College’s web services company caches pages on a too-permanent basis, injecting the occasional miscommunication. The backup site for the course can be found at the personal web page of the lead instructor.