CS365 Final -- Spring 2016

1. applicative evaluation
2. on demand evaluation
3. normal order evaluation
4. strict evaluation

1. garbage collection
2. prototype-instance model for objects rather than a class-instance model
3. ability to create functions at run-time using lambda expressions
4. higher-order functions such as map and reduce
5. powerful macro facilities
6. regular expressions for performing pattern matching in strings
7. dictionaries (i.e., hash tables) as a built-in language feature
8. implicit, parametric polymorphism
9. constructors for data structures, such as lists, that allow a programmer to initialize a structure "all at once".
10. side-effect free execution as a general way of programming

Assuming that buttonGroup is a horizontal box object, how would you assign the buttons and filler objects to buttonGroup to achieve the desired layout?

1. buttonGroup.add(new RigidArea(new Dimension(INFINITY, 0)));
   buttonGroup.add(b1);
   buttonGroup.add(new RigidArea(new Dimension(20, 0)));
   buttonGroup.add(b2);
   buttonGroup.add(new RigidArea(new Dimension(20, 0)));
   buttonGroup.add(b3);
   

2. buttonGroup.add(Box.createHorizontalGlue());
   buttonGroup.add(b1);
   buttonGroup.add(Box.createRigidArea(new Dimension(20, 0)));
   buttonGroup.add(b2);
   buttonGroup.add(Box.createRigidArea(new Dimension(20, 0)));
   buttonGroup.add(b3);
   

3. buttonGroup.add(new horizontalGlue(), b1, 20, b2, 20, b3);
   

4. buttonGroup.add(Box.createRigidArea(new Dimension(0, 0)));
   buttonGroup.add(b1);
   buttonGroup.add(Box.createHorizontalGlue(20));
   buttonGroup.add(b2);
   buttonGroup.add(Box.createHorizontalGlue(20));
   buttonGroup.add(b3);
   

5. buttonGroup.add(Box.createHorizontalGlue());
   buttonGroup.add(b1);
   buttonGroup.add(Box.createHorizontalGap(20));
   buttonGroup.add(b2);
   buttonGroup.add(Box.createHorizontalGap(20));
   buttonGroup.add(b3);
   

Below is a Java pseudo-code representation of the Java code that the intern created for displaying and updating the results of an election:

class ElectionResults extends JPanel {
    int candidateVoteTotal = new int[4];
    JFrame window = new JFrame();
    
    ElectionResults() {
        initializeView();
        pack and make window visible
    }

    void addToCandidate(int candidate) {
        candidateVoteTotal[candidate]++;
        repaint();
    }

    void initializeView() {
        window.getContentPane().add(this);
        for each candidate {
             create a JButton labeled vote
             create a JLabel with the candidate's name
             create a JLabel that display's the candidate's
                 total votes
             add an event handler to the JButton that
                 1) calls addToCandidate with the appropriate index
                 2) updates the candidate's total vote JLabel
                 3) calls repaint
        }
    }
}

• your boss has told you to modify this code so that it conforms to the MVC format, and
• you have decided that ElectionResults will be your glue class

1. Move the candidateVoteTotal array and the addToCandidate methods to a new model class. Remove the repaint() call from the addToCandidate method and add code to the addToCandidate method that notifies each view of the change to the candidate vote totals.
2. Move the candidateVoteTotal array and the addToCandidate methods to a new model class and don't modify the addToCandidate method in any way.
3. Move the view and event handling code to a new view class, but do not change any of the event handling code and do not add any additional methods to the view class.
4. Create an interface that each view implements and that allows the model class to notify each view of changes to a candidate's vote.
5. Keep the candidateVoteTotal array and the addToCandidate methods in ElectionResults. Remove the repaint() call from the addToCandidate method and add code to the addToCandidate method that notifies each view of the change to the candidate vote totals.
6. Keep the view and event handling code in ElectionResults and don't modify any of it.
7. Keep the view and event handling code in ElectionResults but 1) create a method that the model can call to notify the view of any changes, and 2) move the code that updates the JLabel representing the candidate's total votes and that calls repaint() (actions 2 and 3) from the event handling code to this new method.
8. Add code to the constructor for ElectionResults that creates an instance of the new model class, an instance of the new view class (creating the instance will replace the call to initializeView()), and ties the two classes together. The constructor will continue to pack the window and make it visible.
9. Move the code in the constructor for ElectionResults to the constructor for the new model class so that the new model class creates the instance of the view and packs and makes the window visible. The constructor for ElectionResults should be changed so that all it does is create an instance of the model and then returns.
10. Move the view and event handling code to a new view class, and 1) create a method that the model can call to notify the view of any changes, and 2) move the code that updates the JLabel representing the candidate's total votes and that calls repaint() (actions 2 and 3) from the event handling code to this new method.
11. Move the view and event handling code to a new view class and modify the first action in the event handling code so that it notifies any other views of changes to one of the candidate's vote totals. Don't modify either actions 2 or 3 in the event handling code. Finally, add methods to the new view class that allows new views to register and de-register themselves with the view.
12. Add methods to the new model class that allows views to register and de-register themselves with the model.
13. Add methods to the ElectionResults class that allows new views to register and de-register themselves with the ElectionResults class.
14. Create an interface that the model implements and that allows the event handling code to notify the model of changes to a candidate's vote.

public class BadThreads {
    static final int maxTasks = 5;    // the maximum number of tasks that may
                                      // be waiting for execution
    int tasksQueue[] = new int[maxTasks];  // holds the queued tasks, and more specifically the
                                      // number of milliseconds required to
                                      // execute the task
    int taskFront = 0;         // the index of the front of the task queue (i.e.,
                               // the index of the next task to execute)
    int taskEnd = 0;           // the index of the back of the task queue (i.e.,
                               // the index of the next empty spot in the task queue)
    int waitingTasks = 0;      // the number of queued tasks waiting to execute

    class Worker extends Thread {
        public void run() {
	    try {
		while (true) {
		    int taskId = taskFront;
		    int taskTime = tasksQueue[taskFront];
		    taskFront = (taskFront + 1) % maxTasks;
		    waitingTasks--;
		    Thread.sleep(taskTime);
		}
	    } catch (InterruptedException e) {}
        }
    }

    class Scheduler extends Thread {
        public void run() {
	    try {
		while (true) {
		    int taskTime = ThreadLocalRandom.current().nextInt(5, 10000);
		    tasksQueue[taskEnd] = taskTime;
		    taskEnd = (taskEnd + 1) % maxTasks;
		    waitingTasks++;
		    Thread.sleep(ThreadLocalRandom.current().nextInt(300, 2000));
		}
	    } catch (InterruptedException e) {}
	}
    }

    public BadThreads() {
        Worker workers[] = new Worker[3];
        int i;
        for (i = 0; i < 3; i++) {
	    workers[i] = new Worker();
            workers[i].start();
        }
        Scheduler s = new Scheduler();
	s.start();
    }

    public static void main(String args[]) {
        new BadThreads();
    }
}

There are three major bugs in this code. Circle the three choices from the following list that correctly describe these bugs.

1. The Scheduler thread never yields to the Worker threads
2. The Worker threads do not wait on the Scheduler thread if the tasksQueue is empty and hence might try to remove a task from an empty tasksQueue
3. The Scheduler thread may get into a race condition trying to get a random number.
4. The Scheduler thread does not wait on the Worker threads if the tasksQueue is full and hence could try to add a task to a full tasksQueue.
5. The Worker threads could deadlock by both claiming a task and then trying to defer to the other thread that has claimed the task
6. The Worker threads could livelock by waiting for each other to take a task from the tasksQueue
7. The Worker threads can get into race conditions with each other as they update the information associated with the tasksQueue and the Scheduler thread can also get into a race condition with any of the Worker threads over the same information.
8. the Worker threads and Scheduler thread could deadlock by blocking each other from using the tasksQueue.

1. takes a list of (voter, candidate) tuples as a parameter
2. tabulates the vote for each candidate.
3. prints out the candidates in descending order by vote count. If two candidates tie, you can print them out in any order. For each candidate print the candidate's name, a space, and the number of votes they received.

[('nels', 'smiley'), ('brad', 'wolf'), ('nels', 'wolf'), ('sue', 'smiley')]

smiley 2
wolf 1

If your input list were instead:

[('nels', 'smiley'), ('brad', 'wolf'), ('nels', 'wolf'), 
 ('sue', 'smiley'), ('sarah', 'huck'), ('mindy', 'smiley')]

smiley 3
wolf 1
huck 1