Things you should do before too much time passes:

• If I had a dime for everytime someone said they could use a refresher in basic programming / problem solving / computer science concepts… and then this bumps into me: UNSW Computing 1 - The Art of Programming 12 week free course starts December 3rd.

• I'd like to perhaps do some more graphing explorations in class today.
• I hope you've spend some time playing with the GD Library, and the sample code I gave you.

• Thrice readjusted due date on the 2nd sort program, and what do I get? Half the class doesn't even show up. Only 1 sort confirmed complete (although 1 not far behind), and suddenly people's naive sorts are broken beyond comprehension. What the heck is going on here?
• As I picked through the wreckage, I could discern no new clues as to why this assignment was in any way difficult… all the problems I encountered had to do with basic programming logic and syntax. I literally dealt with zero actual sort issues.
  • Perhaps it would have helped if I knew more people had started on this project prior to 3-4 days ago. It seems to be a recurring pattern- start late, have trouble, project is due, suddenly appear for help. The focus is then on getting it done/working vs. actually understanding it, and that is no good at all.
• I have NOT readjusted the due date.
• OPUS Part 3 Keyword is due before it is no longer November 16th.

• Venturing into something a little different- drawing shapes using a graphics library.
  • Good practice for algorithm development (can your image “scale” as image size changes?)
  • There will be a forthcoming project on this; be on the lookout.

• OPUS Part 3 Keyword Selection select a keyword and get started.
• Set program (Part 2) due at the start of class.
• Where to venture to next? Matrix multiplication? I am also wanting to introduce you all to the wonderful world of “the theory of computation”.

• Work-on-stuff day. I am seeing increasing amounts of functionality when it comes to people's set programs. Keep up the good work.

• Due to the potential for interruptions caused by possibly severe weather caused by Hurricane Sandy, all due projects will be pushed back a week. Appropriate projects have been updated to reflect this.

• what did we do today? work on stuff some more?

• work-on-stuff day
• also note that there may be visitors floating about the LAIR during class, potentially asking you questions. Please engage with them and be courteous.

• recursion was talked about, and compared alongside the iterative solution of computing the factorial of a value.
• brief discussion of matrix multiplication

• Naive Sort Program is due at the start of class today.
• Knowledge check- please complete this Discrete Structures Knowledge Assessment by Friday, October 19th, 2012. Please work this through on your own- no external help!

• Functions and Matrix Multiplication. These are the next two topics I'd like to get into.
• Set Program (part one) is due at the start of class today.

• With the impending break, this became another “work on stuff” day.

• Knowledge check- please complete this Discrete Structures Knowledge Assessment by Friday, October 5th, 2012. Please work this through on your own- no external help!
• OPUS Part 2 Keyword is due October 16th.
• Starting this month, I will cease accepting assignments submitted past their due date (unless there are extenuating circumstances). Many people have been getting assignments done on time, others are procrastinating until the last day, and have trouble as they are rushing and don't have much time left. Please don't wait until the last minute, procrastination isn't the way.
• Set Program, Part 1 is due October 11th. I am to do another “wander around and check off” sort of maneuver. Be sure to read the project into for additional requirements.
• Sorting Program: Naive Sort is due October 16th. I also think I'll wander around and check off items for it. Additional project requirements in the project info page.
• Sorting Program: Select a Sort is due October 18th. Here you will be choosing a sorting algorithm to implement (an existing sort).
• Set Program: Part 2 is due November 8th. I want you to extend your set program to support set union, intersection, and difference (working with 2 sets, obviously). See the project info page for more information.
• Sorting Program: Implemented Sort is due November 13th. You've previously picked your sort to implement, spent some time researching it, and by the start of class on this day I want you to have created a functioning implementation of it, extending your Sorting Program to be able to it. I'll wander around and check off for this one as well.

• Another work day on the set and naive sort. I am starting to see some solutions emerge. Great!

• OPUS Part 1 to be completed by October 1st.
• OPUS Part 2 Keyword Selection by October 1st.
• For those that enabled workdue notifications in gimmeh, you may have started receiving daily e-mails (depending on your settings). Remember, it is a double opt-in system- you have to enable workdue-status, AND email-workdue, otherwise it'll skip you by.
• We started an exploration into sorting. I asked the class to implement a naive sort (ie do NOT look up any existing sorting algorithms, I want to see how you approach the problem of sorting based on your own merits). Implement me the following program:
  • Prompts the user for numbers (-1 to stop). Assume random, unordered entry (duplicates ARE allowed).
  • Put those input values into some sort of convenient container (array/linked list).
  • Display the values input, in the order they were input (before sorting).
  • Sort the inputed values from least to greatest (you can use the same container, or use a new container).
  • Display the values (after sorting).

• Be sure to evaluate your received OPUS Part 1 Keyword by September 24th. Then get started on the demonstration before the month is up.
• Sets and Venn diagrams!
• A set is an unordered, unrepeated collection of objects.
• We can use sets as the basis for some comparisons (subsets, equality, partitions, supersets).
• We can even perform some basic operations upon our sets (union, intersection, set difference).
• Many of the logical operations we were playing with can be translated into set-speak.
• I asked the class to write a simple set building and displaying program, that would eventually become some sort of project.
  • Basically it should prompt the user for a value to put in the set.
  • The program should check for and prevent the addition of duplicate data into the set.
  • When the set is loaded up, it should display it using set notation.
  • The Data Structures people could adapt some linked list logic to handle this (good practice).
  • Those not in Data Structures will probably want to use an array.

• Project #0: Logic Operation Truth Table + Function + 3-input + User Input by today, in class. This was a good calibration exercise to see how well you followed directions.
• Project #1: Logic Operation Implemented into class BigNum repository by September 25th.
• Project #2: BigNum-based Increment by September 27th.
• Opus keywords have been swapped! You have until the end of the month to complete your demonstration of the received keyword.
• It was warm, so we did not start on Sets and Venn diagrams. Hoping for Thursday.

• There have been some changes pushed to the bignum repository! Please do an hg pull && hg update from within your cloned copy of the bignum repository.
• Logic program is due on Tuesday, September 18th. I aim to wander around and evaluate each person's attempt.
• As you get this done, start working on implementing you logic operation within bignum (don't for get to add, commit, and push your changes).
• After you finish with both of those, start contemplating the implementation of increment() in bignum. You can assume a single base for starters.
• Have your Opus Part 1 keyword (identification/definition) is due on the the 16th

• Work on that logic/truth table program completed, with the following features:
  • Display the truth table for your logic op
  • Implement a function which houses the programming logic of your logic operation, and have you program use it
  • After displaying the truth table, prompt the user for p and q values, obtain them, perform the operation and display the result
• Doesn't need to be done for today, but I also want you to think about how you'd handle 3-inputs (p, q, r). Have a program that displays a truth table AND user interaction (for Tuesday, September 18th).
• Since we are doing a quickish review of C as we get things rolling, take a look at the bignum repository, try and figure it out, do some research to revive your knowledge on other concepts, and bring questions to class for further clarification.

• Work on the standalone logic truth table programs first. Once those are done, we'll proceed to the Bignum exploration.
• Have the 2-input truth table program for your logic operation finished (or as best complete as possible), so we can try some other variations.
• We'll be using a bignum implementation to play with some of the course concepts.
  • Clone the bignum repository: hg clone http://www/hg/project/bignum-fall2012 ~/src/bignum
  • Go there: cd ~/src/bignum
  • Poke around, look at the source and other non-object files. Ask questions about it. Figure out how it works.
  • Build the library and support files: cd ~/src/bignum; make
  • Look at and play with the examples in cd ~/src/bignum/testing; ls
• The keyword you selected will be the logical operation you will implement using bignums. Start thinking about what that implementation will entail.
• Please be subscribed to the class mailing list and have you keyword chosen BEFORE September 7th. I will be counting both of these as projects.

• I had a request for documentation on setting up the screen/irssi session for class chat. Here it is.
• If you enjoy contemplating incomprehensible objects and seeing their adoption into culture, check out the blivet.
• Using the keyword you picked, please write a small program that displays that operation's truth table (two-inputs, we'll be doing 3 afterwards).
• Please Subscribe to the class mailing list
• and: Select your Part 1 Opus keyword BEFORE September 7th. I will be counting both of these as projects.

• Clone and start using your personal Lab46 Mercurial Repository
• Choose a keyword to work on for Part 1 of the Opus
• Start working on said keyword, for you need to have the definition part done by mid-September.
• Before leaving, detach from any screen sessions (CTRL-a d), log out of any terminals (exit command), close any web browsers or other open applications on your desktop, and right click → exit to log off. You do NOT want to leave while still being logged in!
• Research the concepts of Logic, Boolean, Boolean Logic, Logical Connectives, Unary, Binary, and Truth Table

• Edit/customize the Title and Introduction sections of your Opus by Thursday, September 6th (have it done by 11:59:59pm Wednesday, September 5th)
• Subscribe a frequently checked (or pushed) e-mail address to the class mailing list
• When you come to class, remember to open a Lab46 terminal, which will be used for attendance/participation purposes.
• Make sure you can access the DISCRETE course homepage from home (you may want to bookmark it).
• Make sure you can log into Lab46 from home with your username/password (using PuTTY if on Windows, or some other SSH client).
• Get on the class chat, and familiarize yourself with basic screen usage (attaching/detaching).
• Research the concept of Logic.