Presentation

Graduate Students are required to create a presentation that covers a topic related to object-oriented analysis and design. Valid topics include:

  • An in-depth look at an object-oriented language and the features it provides developers engaged in the task of implementing object-oriented designs
  • An in-depth look at a “new” object-oriented feature or technique that is starting to appear in recent versions of OO programming languages. Examples here include things like:
    • support for concurrency in OO programming languages
    • support for functional programming in OO programming languages; I'm thinking specifically here about Scala's hybrid OO/functional model but other examples may exist
    • support for annotations in OO programming languages, such as Java annotations that were added to the language in JDK 1.5
  • An in-depth look at an object-oriented framework, including its history, its primary concepts (classes) and the services it provides to developers. A framework presentation will include information not only about the framework but will also include a program that shows how the framework can be used. Frameworks written in any OO programing language are fair game. Examples include:
    • The Java Concurrency Framework
    • Prototype
    • The Apache Commons Library
    • Ruby on Rails
    • Django
  • An analysis and design technique that makes use of object-oriented principles and concepts (classes, objects, delegation, inheritance, etc.) in some way. For instance, there is an approach to OO A&D known as Responsibilty-Driven Design by Rebecca Wirfs-Brock and Alan McKean that would be acceptable topic for this assignment. Another example would be Domain-Driven Design by Eric Evans. You are essentially looking for a method that tells designers and developers how to use objects to create OO designs for software systems.

The presentation that you create can consist of a set of slides or a screencast or a combination of the two. The answer to the question “How long should the presentation be?” is that if you were to sit down and give your presentation to the rest of the class, it would take at least 30 minutes. Thus, for instance, if you created a 10 minute screencast to demo some aspect of the framework or technique you were presenting, then the remaining discussion in your slides would contain about 20 minutes of material.

The goal of your presentation is to introduce the topic that you selected to someone who knows nothing about it. Thus, you want to present the basics and arm your audience with enough information for them to be able to explore the topic further if interested.

For examples of prior work, you can view the types of presentations that graduate students created for my software engineering class in Spring 2010. In that context, they were asked to develop a presentation on a software engineering topic. I want to see similar presentations from this class but now directed at topics related to object-oriented analysis and design.

Teams of up to two students can work on developing a presentation. A 30 minute presentation developed by two students should be of much higher quality and/or go into greater depth than a 30 minute presentation developed by a single student. In other words, the fact that two people were working on the presentation should be evident in the final product.

Important: The first thing you should do is contact Prof. Anderson with a proposed topic. We have 51 graduate students enrolled in the class and I do not want 51 presentations on Ruby on Rails! ☺ I will allow up to 2 students to work on the exact same topic, so please submit your topic ideas as soon as you can. As topics become unavailable, I will update this page to show what has been taken (see below).

Deliverables

When you are done, you will submit the following items (in a single archive) to the moodle

  1. A PDF copy of your slides (if applicable)
  2. A copy of your screen cast (if applicable)
  3. A Powerpoint or Keynote or PDF copy of a single slide that represents an “executive summary” of your presentation; the summary covers what your presentation is about and why other students should take the time to view your presentation.
  4. Any source code created to support the presentation (if applicable)

If you plan to submit a screencast, you should contact Prof. Anderson to discuss the details of the format of your screencast. Either you'll be providing a link to where the screencast exists on-line or a link to an archive of the screencast that Prof. Anderson can download and view on his machine. If you plan to do the latter, you should create a short 30-second-or-less video that Prof. Anderson can download to test on his machine. There are several services on-line, as well as for specific operating systems, that allow you to create screencasts (try the search terms “create screencast”) and to display them (such as Screencast.com). Having said that, note that a screencast is not required.

Due Dates

You should have your topic selected and confirmed with Prof. Anderson by the end of week 7, which is Friday, October 12th.

Presentations are due to Professor Anderson by the end of week 12, Friday, November 16, 2012 at 11:55 PM. Students are free to submit presentations early. Due to the advance notice, students will not be able to submit a presentation late. November 16th is a hard-deadline that will not be extended.

Topics Taken So Far

  • Android (2 students)
  • Apache Shiro(1 student)
  • Automatic Generation between code and UML(1 student)
  • C# and .NET (2 students)
  • cocos2D iOS framework (1 student)
  • Concurrency in C++ (1 student)
  • Dependency Injection in the Spring Framework (1 student)
  • Django, the Python Web Framework (2 students)
  • Domain-Driven Design (2 students)
  • Drupal (1 student)
  • GRASP Design Principles (2 students)
  • Guice (1 student)
  • iOS Design Patterns (1 student)
  • Java Concurrency Framework (2 students)
  • libGDX (1 student)
  • Moving from C++ to Java (1 student)
  • New features of C# (1 student)
  • Object Oriented Programming using C (2 students)
  • Object Oriented Programming using C++ (1 student)
  • Object Oriented Programming with Python (2 students)
  • Object Persistence (1 student)
  • Responsibility Driven Design (1 student)
  • Python 3 - History, Data Structures, etc. (2 students)
  • Ruby on Rails (2 students)
  • Scala (1 student)
  • UML: Composite Structures and Component Diagrams (1 student)
  • Using Java reflection to break encapsulation (1 student)
  • XNA and .NET (1 student)


© Ken Anderson 2012