CS 390. Software Architecture (Course Syllabus)

Message archive | File archive

Course Project: To develop software to facilitate the animation of pages in the CSULA-developed National Curve Bank.


Project organization

The project will be developed as a community effort.

BUT

Each student will have his own separate copy of the project.

Use (Even copy) what other people do; 
work together; 
but be sure you understand what is in your copy of the system.  

At the end of the quarter, I will discuss your version of the system with you privately.

you should be able to explain all of it to me.

Note that this organization is different from most class projects. Traditionally a class project is divided into separate portions, each of which is the responsibility of a portion of the class. These portions are then combined to create a complete project. In this project, class members contribute code and information that might be useful for completing the project.  But in this case, each class member is also the chief architect of his or her own version of the project.

 

A note on grading

As indicated in the course syllabus, your grade will be a one (or two) characters letter of recommendation based on the work you do in the course. Two of the primary considerations will be the final product that you produce (see COURSE PROJECT above) and your contributions to the class.

Class contributions consist (among other things) of presentations you make to the class, e.g., about libraries that may be useful to the project, patterns, etc., and code that you post and explain. I especially encourage you to write code that you and others can incorporate into your projects.  

As indicated above, I encourage you to use each others code-- although if you use someone else's code, I want you to understand it. The intent of the course project is that it should be too much work for one person to be expected to do on his own.  Yet you are all expected to complete your own version of the project.  The way to accomplish this is to share code.  Creating code that others can use will be a primary contribution that you can make to the class. I encourage you all to do it.

When you develop a feature to be added to the project, post your code on the web site (http://groups.yahoo.com/group/CS390/files) and then explain the new feature in class so that others can add it to their version of the system.

Please keep a journal of your class contributions so that you can discuss them with me at the end of the quarter.
  1. Initial tasks (listed from most abstract to least abstract).

    Although we will split these tasks among groups in the class, it is important that everyone in the class stay aware of the full range of issues. 

    When developing software it is important to think on all levels at once, from the most concrete to the most abstract, even though one is generally working at one specific level at any particular time.

    1. Survey web sites that include animated mathematics and categorize them by type.  Following is an initial listing of some such sites.

      This is the top level of concern.

      • What sorts of mathematical animations are there? 
      • Which of these will we attempt to support?

    2. Learn about the range of software patterns that we might use. See course textbook Applied Java Patterns. This is a second level concern.  When we build our system, what sort of software architecture structures might we want to use?

    3. Learn about the libraries that might be useful. See Java2D and Java3D. This is a middle level concern. What libraries are available to help us?

    4. Develop a simple concrete example of an animated page as a way to see how it might be done.  This first example will not be general or flexible, but it will illustrate some of the programming techniques that we will use, and it will provide a concrete reference point for further development, something like the Hello world program one writes when first learning a programming language.

      This is a bottom-level concern.  How can we get something actually running, even if it is very simple?

      It is important to have something working all the time.  Development should not proceed on a big-bang theory: that we work for a long time and then all of a sudden we have a working system.  We want to have a working system all the time. As development proceeds, the working system that we have at any moment will be increasingly powerful and sophisticated.  But at any moment, we should always have something that works.

      First result: http://abbott.calstatela.edu/courses/CS390/CurveBank/SineCosineApplet.html

  2. Second step tasks. 

    1. Put the existing code into packages that organizes it in terms of the Model-View-Controller pattern. Everyone should make a copy of the code and do this.

    2. Notice animation features on other web sites that we don't yet support.
      • Navigate around the plane (and in 3-space when we get there).  Do you like arrows to indicate navigation options?  How about an icon that takes you back to the center of the plane?
      • Zoom.  Do you like + and - buttons?  An alternative (at least for zooming in) is to allow the user to outline a rectangle and letting that be the new area displayed.  You still need to zoom out.  How should that be done?
      • Highlight buttons when the mouse passes over them to indicate that they are alive.
      • Drag points on curves to deform them.
      • Summation as a mathematical operator. (Presumably we will support the arithmetic operators as well as the functions in the java.lang.Math package.)
      • Animation, where the slider moves by itself (once started) and at human speed.  It should have start and stop buttons.
      • What is animated? At each point a complete (but parameterized) curve might be drawn. Or, perhaps the animation is continuous without a slider indicating a parameter.
      • Three dimensional images and operations.
      • Format mathematical equations.  In general, this is quite difficult.  Can we do something useful without doing the entire job? The displayed equations should be updated as parameters change.
      • Allow the user to enter equations textually. Look at the Interpreter pattern in the text.
      • Provide an Undo button.  Look at the Command pattern in the text.

      Everyone should implement at least one of the above features in your copy of the code.

    3. Third step tasks.

      Now that you have your version of the system working with one or more of the enhancements listed above, it's time to start thinking about additional features. A number of people have implemented various of the features above.  Add some features that other people wrote to your version of the system.  In addition, here are other capabilities we may want to include.

      1. Synthetic synesthesia. Synesthesia is a condition in which a stimulus in one sense modality, e.g., sight, is involuntarily elicited in another sense modality, e.g., taste. See www.mixsig.net, www.users.muohio.edu/daysa/synesthesia.html, and web.mit.edu/synesthesia/www/synesthesia.html for more information about synesthesia. As wearcam.org/visualfiltersynesthesia.html points out, synesthesia, can be very useful.  In some sense any GUI is an example of synthetic synesthesia in that it makes available visually information that is perceived by some virtual sense. By providing synesthetic options, users of the CurveBank may be able to understand and remember curves more easily.  

        The issue for us is to provide ways for users to associate colors and sounds (and other properties?) with curves or curve features.  For a not-very-satisfying example, see www.well.com/user/smalin/mam.html in which colors and curves are associated with music.  We want to go in the other direction, i.e., given a curve, allow users to associate sounds (including music) and or colors with it.

      2. Laws of motion. The MouseWork system includes objects moving according to very naive laws of motion. It would be useful to have some more properly fleshed out laws of motion available as a library.

      3. Building an animation. Developers of CurveBank pages may want to include some but not all of the features we have investigated. Can we provide an animator's studio through which a CurveBank author could point, click, and drag features into an animation and design the animation layout to suite his taste and needs?

      4. Libraries. Look at your classes and see which of them might be useful outside your specific organization. For example, do you have labeled axes, i.e., axes with tick marks and numbers next to the tick marks?  (If not, you should consider adding them.) Once you have them, it would be a good idea to encapsulate that capability in a class so that you and others could generate labeled axes more easily in the future. Are there other classes that might be useful outside your specific system? If so, consider how you can make them available.

      5. More Mathematics.

      6.  Integrate and abstract 2D and 3D. We investigated both Java 2D and Java 3D, but we don't yet have a means of integrating them. An integrated version would allow one to develop a model that is independent of the way in which it might be displayed. The user (or developer) could then chose to display that model in either Java2D or Java3D--without changing the model, e.g., by clicking a button or checkbox.  More generally, if we had multiple ways of displaying information in a model (see synthetic synesthesia above), it would be useful if the same model could be displayed in any of a number of ways simply by making a selection from a GUI.  

        1. What sort of model organization would facilitate that? 
        2. What additional information is needed to allow that model to be displayed in 2D? in 3D? Can that additional information be segregated from the model and provided only when display in either 2D or 3D is desired?

    4. Fourth Step Tasks. Refactoring Exercises
    5. Additional explorations: Java3d.
      1. Download and extract the Java3D tutorial and examples from http://java.sun.com/products/java-media/3D/collateral/.

        Note that the examples file is examples1_6.jar.zip, a .zip file containing a single .jar file. Extract the .jar file from the .zip file. Then open the .jar file with winzip and extract its contents, which are a collection of .java files. Assume you extract the example .java files to a directory called .../CS390/Java3DTutorial/Examples.

      2. Create a JBuilder project for the examples.
        • In first creating the project, call the project Examples, and identify the directory as .../CS390/Java3DTutorial/Examples. This will become the working directory.
        • Let the output path be: .../Examples/classes.
        • Let the Backup path be: .../Examples/bak.
        • Define multiple Source Paths: Examples/Animation, Examples/easyContent, Examples/geometry, Examples/HelloJava3D, Examples/light.
        • Comment out import Axis; from AxisClassDemoApp, which is in the geometry directory.
        • The project should build successfully.  You should be able to execute the .java files (such as the HelloJava3D series) that contain main() methods.  We will look at these first. 
        • Retrieve Java3dTutorial/Examples/HelloJava3D/HelloJava3DPlus.java. This extends the basic HelloJava3D example offset the axis of rotation. It also includes mouse zooming so that the cube can be made to remain visible as it rotates. 

      3. Java3D documentation.
        • Download java3d-1_3_1-doc.zip, the Java3D API documentation. (It is called the implementation documentation on this page.)
        • Extract it to the same Examples directory used above. It will extract to a directory called html.
        • In JBuilder > Project Properties > Documentation, set that directory (.../Examples/html) to be the project documentation directory. You should now be able to click the mouse over a Java3D class or method, press the F1 key, and see the associated documentation.

      4. Latest HelloJava3DExample.zip file.

 

My home page