1/30/06
Hurray, Breaks over. Here is my current plan.
- The Visualizer is going to rewritten to be a library function which can be called at any time to draw/redraw a data structure.
- Data can be stored in any manner by the program using the visualizer, and some sort of function to create a renderable data set and populate it with a linked representation of the data. The structure of the data can then be determined by the link structure.
- A function to draw whatever data is currently in the linked representation stored in the visualizer library.
I hope this approach will allow this to be used for a number of different purposes, comparing tree transformations and preforming speed analysis of different data organizations.
12/07/05
- After attempting to implement a display function for trees, I have realized that I have reached about the end of the line for the current design of this project. In order to continue the expansion of functionality for this project I am going to have to redesign the structure of the classes and how they are implemented. Since Java is heavily Object Oriented, a lot of the restructering of the classes will be relativly simple and shouldn't require to much in the way of writting new code, just slightly modifying the stuff I have and changing which class calls what.
- The first thing I am going to have to change is to make the data structure class the class that instantiates everything, basically change my program so that it is more like an included library then a body of code you have to crack open to implement a new data structure.
- So I think the requirements I have come up with so far.
- datastructures are composed of data objects.
- data objects contain: the data (duh), a notion of the next data object(s), a notion of posistion, and a function to draw themselves
- the data structure extends a JComponent and breaks the available area up into 'cells' which the data objects can inhabit. There should be a direct conversion between cells and pixels, but this can be hidden from programmers so they only need deal with cells
- the position of each data object is based on the posistion of its parent data object, the relation can be changed depending on the type of data structure
- the data structure contains the event loop, which returns a set number of actions then the data structure acts on those actions however appropriate.
- The results of these requirments are:
- Only one data structure can be displayed by an instance of this program
- Programmers who want to implement other data structures not supported, will have to go through a more complicated process.
12/05/05
- Created documentation for my project using javadoc(see link above)
- Refined the user interface and added some options for the user, colors, and line widths and the like
- At this point the stack adt (using a java stack) is completely done. I still need to implement a remove function to allow the user to remove a stack from memory, but that shouldn't be hard.
- About the only thing I need to finish up for this semester is implement another data structure or two, just to show off the program for the presentation...
11/17/05
- I finally finished the general framework of visualizer, and am now ready to start implementing display functions and data structures.
- I need to find out why my program is running at an incredibly slow pace...It is crawling, but I havn't added that much more code to it, I think that some class I am including is hitting me big, or maybe some call to a graphics function that I am not really understanding. I'll see if Charlie or Kevin have any suggestions.
- I talked to Ebru and she said the two ADT's she would like to have for CS256 are a stack and a queue, that shouldn't be hard at all (if everything else works the way I think it should...) so hopefully I will have those going soon, at least for next semester.
11/11/05
- The code for this project has been completely restructured to fit with the stuff that kevin has been working on. Currently, the GUI is containted in the main class along with declarations for an adt wrapper which contains all of the meta data about the ADT, and a generic ADTType which I am hoping will hold default functions for drawing ADT's of different types, (tree, stack, queue, linked list, etc, etc) These may be a while in comming, but I hope to have atleast a stack done soon.
- More recently I have been working on getting the ADTType to correctly extend the JComponent class so that Java will handle the updating of the ADTTypes drawing functions. Which I just finished yesterday, yay.
10/30/05
- First of all, let me apologize for "falling off the wagon", I believe the phrase was. Since the last time I updated this journal I finished the UI, and converted the program into something with three distinct levels. The ADT's are all on one level, the internal program data, which stores all the information about the ADT's and the user interface and everything else that needs to be stored, and the UI, which simply displays whatever is in the data class, and passes whatever the user does to the data class. I am currently pretty excited about the project, I think that it will end up being pretty extensible and (assuming that whoever is working on it knows java) fairly easy to create other ADT (and hopefully some algorithms) to display with the framework here. The next thing I am going to work on is finding a way to take a snapshot of the ADT to allow users to play animations forward and backward. I would also like to find a way to break the animations up into discrete frames so that the user can step through a process frame by frame. Those two features are two of the most desireable in software visualization tools according to the reading I have been doing.
10/17/05
- I have most of a UI implemented and working pretty well. At this point all it does is print the signals that it would pass to the driver program, if that program existed, but its a start. The UI consists of a list of the various data structures the user has open, a graphic area to view the data structures, and a command line interface for manipulating the structures. I am still having some issues figureing out some of the finer points of Java classes, but Kevin has been a great help.
10/11/05
- A first attempt at a minimal language definition to be used in the command line of the program. A work in progress.
10/9/05
- Things needed for program interface:
- Simple Command Line
- Graphic Display
- Ability for user to create/modify/destroy a data structure
- Easily extensible command parser
- After reading a paper by some GA Tech professors about user interface design, I would like this to be as much like programming as possible. I don't think this is realistic but it would be nice if the user could type C commands, for example, into the command line and see the results on the screen in graphic form. Implementing subroutines would be a nice feature, but I don't think that is at all possible.
- The ability animate a sequence of events and then replay it, pausing, and reversing the action do review it over and over again would be great.
9/29/05
- I've been thinking about exactly what it is I would like my code to do. I've read a paper by a group of professors who designed a series of animations to demonstrate various sorting algorithms. Visually their program is very understandable but it lacks the sort of control I would like to implement. I would like to be able to move backwards and forwards through a peice of code, sort of like the debugger. I would like to find a way to make this code easily adaptable to any ADT or algorithm. I'm thinking that I could write some sort of display function that would display array of ints as a series of bars, and maybe adapt that function to display a couple of different basic data types, and then let the user provide the algorthms to manipulate those data types.
- I think I've got the basics of Java down, I wrote a simple calculator program just to get my feet wet, I think next I am going to try to adapt that program to use the OOP features of Java, different classes and passing variables around and stuff like that. The next step after that is going to be implementing a GUI (Enter your name: .... Hi [name], that kind of thing)
9/17/05
- Put Journal up.
- Currently working on my revised abstract. Right now I'm thinking that my project is going to focus on developing tools to teach some of the more abstract structures in CS256 (BST, B-trees, etc). I'm also working on comming up with a way to make my code more modular, so given some libraries I'd like to create, anyone could generate a data structure populated with some object i'll create, and it would render itself in some logical fashion. I'll have to think about that some more.
- Learning Java