CSCI 201 Lab 2 -- jGRASP

This week we are going to show you how to use jGRASP, a Java IDE (Integrated Development Environment) developed at Auburn University. Because jGRASP itself is written in Java, it can run on any platform that supports Java. This means that you will be able to use jGRASP on both Linux and Windows platforms.

We will only describe a few features of jGRASP in CSCI 201. To become a jGRASP guru, you should consult the jGRASP Handbook which may be found on the CD-ROM bundled with your textbook or downloaded from the GRASP project home page.

Starting jGRASP

On your Linux machine, start a terminal session and then type the command "jgrasp". You can also configure GNOME to start jGRASP through the menu system, but we won't discuss that here.

First view

Linux jGRASP starts with two initial windows (as does the Windows version). The first
Linux jGRASP control
is a small window that is actually displayed by a small C program used to control jGRASP. You can ignore this window unless you need to terminate jGRASP.

The second window gives an ominous disclaimer about "bugs".
Linux jGRASP warning
Just press the Don't Show Again button and go about your business. Soon the Metal interface will be displayed which should look something like this:
Metal interface

Creating a project

jGRASP, like many IDE's, uses projects to organize programming tasks. A project is a collection of related files used to solve a problem. Although you really don't need projects in your early CSCI 201 assignments, you might as well get into the habit of using them.

Our standard project directory

Projects will be stored in subdirectories of your personal csci/201 directory. Although these projects will persist between Linux login's, you may want to transfer these projects to a floppy you can take home. We'll show you how to do that later in this lab.

Getting to the standard directory

First follow the menu bar choices ProjectNew Project ... to bring up the New Project dialog. This dialog was created using the Java Swing file search interface, something you may want to learn more about in the future. There are two boxes near the words "Look In". The box to the right can be used to move down the directory hierarchy (toward the root) or to move to different drives. The much larger box, which is below Look In, is used to move into subdirectories.
Linux directory

Now head toward csci/201. If you are having trouble following the "path", you might check out our Extremely Tedious and Detailed Guide to jGRASP Directory Search.

Creating a new subdirectory

In our labs, we're going to create a new subdirectory for each project. We recommend you also follow this practice in your programming assignments. To do this, press on the icon that vaguely looks like a file folder, New Folder icon. When you pass your mouse over this icon, the words "Create New Folder" should appear.

A new folder called New Folder will appear. Rename this new folder Lab2a. This maneuver can be difficult for even the most experienced Windows or Linux user. You must gently and patiently click the words "New Folder" until they are highlighted. Then you can edit the file name. If you are getting very frustrated in your renaming, check out our Extremely Tedious and Detailed Guide to jGRASP Directory Creation.

Double click on your newly created Lab2a directory icon to move into it. Finally, type the word "Lincoln" into the text box labeled File Name and click the button labeled Create. A new project named Lincoln.gpj will be created in the Lab2a directory.

If you look in the left pane with the Browse tab selected, you should see something resembling the following:
Linux browse

jGRASP project creation checkoff

This is your first checkoff point. Show your lab instructor your jGRASP window, so that he/she can verify that you have created the project in the right directory.

Creating a Java file

Yes, it's finally time to actually create a Java file in jGRASP. First you must create an new CSD, or Control Structure Diagram, window for the code. Do this from the menu bar as FileNew FileJava.

The new CSD window will appear in the right pane. Notice that the CSD window has its own title bar and menu bar. Note that menu bars of both the main jGRASP window and the CSD jGRASP window have a choice labeled File. This can get confusing.

You'll probably want the CSD window to fill the right pane. Mash the CSD's Maximize icon, Maximize, to make this happen.

Cut and paste the following familiar Java program into the CSD window using the CSD's EditPaste.

public class Lincoln
   public static void main (String[] args)
      System.out.println ("A quote by Abraham Lincoln:");
      System.out.println ("Whatever you are, be a good one.");

Using the CSD's FileSave As ... menu choices, save your Java code in the file within the Lab2a directory.
Saved File

(Note: If you are using Windows at home or in another lab, you should save your file in "Binary/Unix" format. If you don't you will discover that, when you reload your Java program into jGRASP, the two-letter "word" OD will appear at the end of each line. This is actually, 0D (zero-D) the hexadecimal representation of the enter key. You may consider this a jGRASP bug.)

Binary save

Adding your code to the project

Follow the CSD's FileAdd to ProjectRelative Path trail to actually add your Java code to the project.

If you press the Project tab of the right pane, you should now see your Java program associated with the jGRASP project.

Project view

Compiling your Java code

At last it's time to generate some bytecode. You have three choices for doing this.

  1. Press the CSD's Compile File icon, Compile icon
  2. Navigate the CSD's CompilerCompile menu selections
  3. Type control-B

The bottom panel of jGRASP should display a message that indicates successful compilation of your program. If it doesn't, you need to get the attention of your lab instructor.

Running your Java bytecode

You have three ways to run your program.

  1. Press the CSD's Run application for current file icon, Run icon
  2. Navigate the CSD's RunRun menu selections
  3. Type control-R

The bottom panel of jGRASP should automatically select the Run I/O tab and display the output of your program.

jGRASP program checkoff

Show your lab instructor the result of running your program.

Exiting jGRASP

Use the "main" jGRASP window to terminate jGRASP. You may also have to terminate the smaller jGRASP control window.

Saving your project to a floppy disk

We all know floppy disks are a somewhat dated way to transfer data, but they'll do in a pinch.

First of all, it is recommended that you format your floppy disk on a PC running Windows before using it on the Linux computer. After you place a floppy disk into your Linux computer, the root directory of the floppy disk will appear as the directory /mnt/floppy as soon as you mount it. Then you can use the cp -R, copy recursively, command to move all the files of a specified directory, such as your jGRASP project directory, to the floppy disk. Next, use ls -R, list recursively, to view the entire contents of the floppy disk. Finally, unmount your disk. Here are the commands for performing the transfer to floppy disk. Notice that the last command is "umount", not the more natural "unmount".

[user@mach dir] mount /mnt/floppy
[user@mach dir] cp -R csci/201/Lab2a /mnt/floppy
[user@mach dir] ls -R /mnt/floppy
[user@mach dir] umount /mnt/floppy

Project transfer checkoff

Show your lab instructor that you have copied your project directory to your disk.

Downloading a Java archive

In this course you're must frequently download collections of files for use in labs and assignments. We're going to use jar, or Java archive, files for this purpose in CSCI 201.

In your browser right click on the following link for the Java archive for part B of Lab 2. We recommend that you save the file in the directory csci/201.

Although jGRASP offers jar file extraction capabilities, it is easier to use Sun's jar file extractor as follows:

[user@mach dir] cd csci/201
[user@mach dir] jar xfv Lab2b.jar
   created: META-INF/
   created: Lab2b/
  inflated: Lab2b/Lab2b.gpj
  inflated: Lab2b/

In the first command, cd csci/201, we are setting our current working directory to be csci/201, the directory containing the archive file Lab2b.jar. The command jar xfv Lab2b.jar unpacks or "expands" the archive file. Now give the command ls -R to see the directory (and its contents) created by unpacking the archive file.

(Note: if you are using the Windows version of jGRASP at home, it is very important that you use the jar command to extract files. The Windows version of jGRASP has a bug in its jar file extract routines.)

Opening the project

Restart jGRASP. Use the ProjectOpen Project ... menu choices to open project Lab2b . Select the Project tab of the left pane and then double-click on the entry. A CSD windows containing Java code should appear in the right pane. You'll probably want to maximize the CSD window.
Lab2b project
Ignore the jGRASP message that your files may have been edited outside of the control of jGRASP.

jGRASP jar extraction checkoff

Show your lab instructor that you have extracted your project into the right directory.

Yes, there are a lot of checkoff points in this lab. We're just trying to make sure you get started on the right track.

Your first Java programming assignment

Writing your program

Let's take a little time to look at your first Java programming assignment and learn a few principles of program design that will help you throughout this course. Remember, programming is problem solving and the first thing that you have to do in solving a problem is understand the problem. In your first assignment, you are asked to convert seconds into hours, minutes, and seconds; for example, 11,111 seconds is equivalent to 3 hours, 5 minutes and 11 seconds. You have to understand how to do this conversion, before you can tell a computer how to do it. Write down the steps involved in converting seconds to hours, minutes, and seconds. You don't need to write in complete sentences, just a brief two or three word phrase can be used to describe each step. Contact your instructor if you have trouble formulating these instructions.

Now that you know how you would solve the problem, you can begin to write instructions for the computer to solve it. Remember, in addition to performing the necessary calculations, the computer must also obtain the necessary data (read input) and print the answer (write output), so, at very high level, most programs consist of the following three steps:

We can refine these steps to provide more detail without writing complete Java statements. For example, we could provide more detail about input and output as follows:

Of course, since you are writing these instructions for yourself, they could be briefer or more code-like, for example:

Semi-English representations of a program such as those above are called pseudo-code. Write the pseudo-code for the calculations that need to be performed in your program. Remember two things:

  1. When two integers are divided the result is an integer---there is no decimal value. For example, the expression 5 / 2 evaluates to 2 not 2.5.
  2. The remainder operator (%) returns the remainder after integer division; for example, the expression 5 % 2 evaluates to 1, the remainder when dividing integer 5 by integer 2.

The remainder operator can be very useful in your problem; for example, the total number of seconds remaining after converting 11111 to minutes is 11111 % 60 .

Programming Project 1 pseudo-code checkoff

Show your lab instructor the pseudo-code for your first program.

Implementing your program

While it's a good idea to design your program "from the top down"--- looking at the entire problem and breaking it into small pieces, it's equally important to implement your program "from the bottom up"---implementing the pieces one at a time. Don't implement your entire program at once, instead, test the pieces one at a time so that if a piece doesn't work, you know which piece it is.

A good starting implementation for your first program might look something like this:

import cs1.Keyboard;

public class Time
   public static void main (String[] args)
      System.out.println ("enter a number of seconds");
      int totalSeconds = Keyboard.readInt();
      System.out.println ("You have entered " + totalSeconds + " seconds");

This implementation verifies that you can do input and output before you start trying to do your calculations. If this implementation works, then start adding your calculations checking them as you go. For example, your next implementation might look something like this:

import cs1.Keyboard;

public class Time
   public static void main (String[] args)
      System.out.println ("enter a number of seconds");
      int totalSeconds = Keyboard.readInt();
      int seconds = totalSeconds % 60;
      System.out.println ("seconds = " + seconds);

Don't make the process of implementing your code too tedious by implementing and testing un-necessarily small chucks of code. Use your own judgment in deciding how much code to implement and test at once, but don't forget the advantages of incremental implementation.

Isn't that enough

Go home.