FHTW Berlin Fachbereich 4 Internationale Medieninformatik PROG1: Programmierung I Wintersemester 02/03

---

Introduction

It seems to me that we need some more work on interactive control loops. Many people are complaining that they are getting something to work, but they don't really understand what they are doing. So let's get down into animacy, even if we haven't had the lecture on that yet :-)

This week's laboratory project only involves writing a "public void run() { while (true) { ... } }" interactive control loop, this is, an object that acts on its own.  We've designed a teeter-totter (i.e. see-saw) of sorts, and your code will act on its own to balance the teeter-totter.  This lab will introduce you to the concepts of creating a new Thread and using it to create an "animacy", as well as the use of constructors in you code. Threads are something that are built into Java, I suggest looking it up in the JavaDoc to see the kinds of methods a Thread has.

This lab will detail building a self-animating object from the ground up.  It reviews the idea of defining a class - a recipe from which objects can be made - and incorporates the ideas of communities of interactions seen in the previous labs.

This assignment emphasizes and reviews the following topics:

• Defining a Java Class
• Constructor Method
• Creating an Animacy
• Behaviors of Entities/Behaviors of Aggregates

As per policy, you are encouraged to discuss in detail this assignment with you classmates, but you should do the write-up on your on.  You may also get comments from other students on all poritons of your write-up before turning it in, if you wish.  Please include the names of anyone with whom you collaborate, in any way, on this assignment, and indicate the nature of the collaboration.  [Failure to include this information is a violation of the collaboration policy.]

Contents

• Introduction
• Pre-Lab
• Finger Exercises
• Lab Preparation
• Laboratory
• What to Bring to Lab
• Getting Started
• Compiling Your Code
• Things to Try
• Sample Balancers
• Post-Lab/Writeup

Pre-Lab

A. Finger Exercises

class Foo {
    private int bar = 0;
    public void method1() {
                                // line 1: bar is
        bar++;
                                // line 2: bar is
        int bar = 5;
                                // line 3: bar is
        bar++;
                                // line 4: bar is
        if (true) {
                                // line 5: bar is
            int bar = 10;
                                // line 6: bar is
            bar++;
                                // line 7: bar is
        }
                                // line 8: bar is
        bar++;
                                // line 9: bar is
    }  // end method1()

    public void method2() {
                                // line 10: bar is
        bar++;
                                // line 11: bar is
    }  // end method2()
}  // end class Foo

Assume now that the following code is executed:

Foo foo = new Foo();
foo.method1();
foo.method2();

System.out.println("The value of bar is " + bar);

2. Now assume that the following code is executed (i.e., continuing on after the execution of the code in 1, above):

Foo fooToo = new Foo();
fooTwo.method2();

3.  In the code defining class Foo, which of the lines bar++ could be replaced by the line this.bar++ without changing the execution of the code?  (You can identify the lines by the line number following.)

4. Now consider the following code, which implements a simple counter:

public class Counter {
    private protected int currentValue = 0;
    public int next() {
        this.currentValue++;
        return this.currentValue;
    }
}

Counted count = new Counter();

if (count.next() > 1) {
    System.out.println("First case");
} else if (count.next() < 1) {
    System.out.println("Second case");
} else if (count.next() == 1) {
    System.out.println("Third case");
} else {
    System.out.println("Last case");
}

B. Preparation for Lab

In our simulation, there are three (main) entities: the agent at the end of the teeter totter, and the graphical user interface (GUI), which allows the agents to interact with each other and with a user.  Each agent, looking at an end of the teeter totter, sees only the relative slope (up and away or down and away).  The agent can choose to raise or lower the end.  A typical agent will sense the end's slope, perhaps make some calculations, adjust the end, and then go back to sense the slope again.  Your job is to implement such an agent.  But first, to acquaint you with the problem....

Running the Demo (Optional)

Click and hold on that control menu at the top of the screen to get a list of possible options.  Select "Start" from the menu.  The TeeterTotter should level off fairly quickly.  Try playing with the controls at the top of the screen; these controls create a weight that can affect the balance of the TeeterTotter.  Play with these controls a little and see what happens.

Sitting at an End...

Unlike Spirograph, your job is not just to write the control rule.  However, in preparing for the lab, you may want to consider what such a control rule would look like.  That is, if you knew the slope of the End, how would you want it to move?  The End's slope is a float; positive means that the line slopes up and away from you, negative, down and away.  Similarly, your command to tell the End how to move gives it an int: positive to rise, negative to fall.  There are also limits to how much pushing you can do, you'll discover these in lab.  Don't worry about the form of the Java code yet; just think of how you would like to incrementally (one move at a time) control your End.  Come up with several rules and make notes (in English or German) about them.

When you get to lab, you will be able to define a few different approaches, which you can test against one another; you can also test your definitions against each other's classes, or against some that we will provide.

Down to Details

1. define a class that is capable of being self-animated.  What interface must you class implement?
2. ensure (through you class's constructor method) that each instance of your class has its own animacy.  What built in Java type is an animacy?  How do you get it going?
3. give that animacy some place to start.  Where does an animacy always start?
4. ensure (through you class' constructor method) that each instance of your class has its own End.  This will be supplied to each instance as it is constructed.  How do you indicated that such information is necessary to make an instance of your class? Given that you're going to need the End later, what should you do with it?

About the End

An End is a Java object that lets you ask it for its relative slope and tell it how to move. The interface looks like this:

package balance;

public abstract interface End {

// Methods
float getSlope();
int moveEnd(int p0);
}

If e is an End,

1. how do you ask it for its slope?
2. what does a slope of -5 mean?
3. how do you ask e to rise?

Final Details

Sleeping on the Job

1. Your agent runs a tight loop: it may be difficult for any other code to run.
2. The code runs so quickly that it is difficult to see what's happening.  Changes take place before you have a chance to observe them.

try { Thread.sleep(100); }
catch (InterruptedException e) {}

A Little Math...

One particularly useful method you may want to use is Math.round.  This method takes an argument of type float and round to (and returns) the nearest int.  A typical usage could be:

int myInt;
float myFloat;
// ... more code here ...
myInt = Math.round(myFloat);

Publicity

Wrapping up

Make sure you understand everything in this section before you write any code.  If anything is unclear, please ask!

Beyond the constraints described above, your code and do pretty much whatever you'd like.

Laboratory

What to Bring to Lab

1. your finger exercises
2. some (English or German) strategies
3. predictions on how these will work
4. an outline or draft of a basic class, including the appropriate constructor and animacy mechanisms
5. answers to the various questions asked in the pre-lab
6. a development plan, starting with the simplest working code that you can imagine (e.g., code that compiles, says "I'm here", and doesn't do anything else) and gradually building up to more complex functionality.  Also indicate how you will test each stage.

Getting Started

The next section describes in more detail how to actually edit, complie, and run your code.

Compiling Your Code

In lab

In order to work on this problem set in lab, you will first need to do a bit of setting up. You will have to make a new project, add the balancer.jar file, set the Main class, and then create your own file. Select new class from the files menu, and make sure that you select the correct directory (there's a little drop down menu for the package name). Setting up class paths in Java is a black art!

Have a look at the interfaces for the files given: Balancer1, Balancer2 and Balancer3. How to look at the interface? Use the Searching menu and search for the classes. Voilá, this is not the implementation, but the interface, and it looks good! This gives you all the fancy import magic you are going to need.

To run the Teeter-Totter with you code, you need to do the following:

1. Select the project properties menu.
2. Select the little start tab
3. In the box that says "Program Arguments", enter the name of your class twice.  Remember to put the package name in front of it! For example, if you were using the Balancer1 you would write
   balance.Balancer1 balance.Balancer1
   This will load your code as both ends of the Teeter-Totter.  You can vary this later, giving other classs names to try out other configurations.

Things to Try

Sample Balancers

Balancer2 Balancer2

• Balancer1:  This is the default balancer.  It does a decent job of balancing the teeter-totter, but the weight gives it problems.  If you give no command line arguments this balancer controls both ends.
• Balancer2:  This balancer handles the weight better than Balancer1, but is somewhat slow and not all that stable.  Can you make a balancer that stabilizes this one?
• Balancer3:  This is the most stable and robust balancer of the group.  It is able to effectively deal with the weight and it fairly fast.  Even bad balancers look good when run with this one.  Can you make a balancer that produces oscillations when run against this one?

The Balancer Fights

Now ask around for other peoples balancers! Take theirs on one side, yours on the other - see who wins! A lot of fun can be had if you have a de-balancer fighting against a balancer! Include the names of the people you competed with in your report! Who wrote the best balancer in the class? The best de-stabilizer?

PostLab/Writeup

1. How long did it take  you to bebug your code?  What was the hardest bug to find/fix?  What techniques worked to help you find your bugs?  What was the most helpful suggestion you gto?  What was the most subtle error you made?
2. How quickly does your original algorithm balance the TeeterTotter?  How robust is it to jitters?  How well does it rebalance?  Can it handle the weight?
3. How do your different algorithms compare?  Which ones balance best when competing with themselves?  Which ones are most robust to jitters?  Which ones complete well?  Why or why not?  What features matter?  (You can do some additional experiments to try to figures this out.)
4. How do these observations match your predictions?  Why or why not?
5. If you tried to do other things, like to get the TeeterTotter to oscillate, how successful were you?  How well did the behavior match your predictions?  Why or why not?

• your pre-lab assignment
• experimentation notes:  recorded observations, interesting behavior, advantages one balancer type enjoys over the other.
• finger exercises: both #1 and #2.
• code design notes: at least two strategies for moving in responce to a slope.
• answers to the specific questions asked in the lab preparation section.
• a discussion of how you spent your time in lab.
• your observations concerning:
• what actually happened
• how this compares with what you expected prior to the lab
• how the behavior of the teeter totter was affected by the strategies of th two end-controlling agents
• answers to any questions you were asked during check-out
• the names and roles of any collaborators in any parts of the project
• also note the following (briefly):
• how long did this lab take you?
• did you work with other students?  If so, how helpful was it?
• did you have problems writing code for this lab?
• did you have problems running/using this lab?