Joe Atzberger

Although this is my senior year at OSU, I am not as far into the Computer & Information Systems courses as some of my younger colleagues: my original field of study is actually English! Having already completed the coursework required for an English major, my scholarly attentions are now dedicated to CIS and my honors thesis. This is my third quarter with Europa.

Outside of the lab, I generally manage OSU's Student Radio Station The Underground (broadcasting on the Internet for over 2 years), dance tango and other ballroom styles (thanks to the University's social dance classes) and sit on the editorial board of Mosaic (OSU's annual Undergraduate Art & Literature publication).

Index:

Research Interests
Current Projects
Completed Projects
Return to Europa

Research Interests:

I am most interested in computers as a cultural phenomenon, and specifically in the mutation of text and writing under the weight of electronic communication. Much of this interest plays out in my Honors Thesis, a hypertext fiction: I am currently writing narrative segments and programming the java structure necessary to implement it. This thesis allows me to combine postmodern literary criticism theory and my own creative writing efforts with computer progamming skills and technological capabilities. There is interest in my current fiction writing class to extend the java interface to enable multiply-authored non-linear hypertext.

In Europa, I like to focus on pedagogical aspects of programming and interface, as well as the University designed language of RESOLVE. Most of my functional programming experience is in Java/html and RESOLVE/C++.

After graduation I plan to spend at least six months out of school, when I will actually be able to focus on comparing graduate schools. Among the top contenders: OSU (Education), U. Texas at Austin (Computer Composition), Carnegie Melon, and University of Chicago.

Current Projects:

• The RCPPParser:  Translating RESOLVE/C++ to JAVA:


Ohio State University teaches a specific discipline/dialect of C++ called RESOLVE/C++.  It enforces on C++ a strongly typed, philosophically verifiable sensibility: to the often unruly and bug-prone C++, this is a great favor.  However, compilation to C limits the portability of RESOLVE programs and imports many unwanted linguistic artifacts.  Shawn Hendricks and I decided, in the context of Bob Mathis' CIS 655N, to attempt a new compiler, one that would produce portable executables.  While JAVA is far more object-oriented than RESOLVE, JAVA byte-code is capable of running independent of platform on any JVM (Java Virtual Machine): we targeted JAVA byte-code.  And, while we were at it, we hoped to enforce more of the RESOLVE discipline at compilation, catch additional syntactic and semantic errors and increase the specificity/usefulness of reported errors.

We needed several components:

• Formal lexicon and syntax (already established, maintained by Paolo Bucci)
• Lexer or Tokenizer to divide source code into chunks
• Parser to ID unresolved tokens, ensure valid semantic relationship between tokens
• Accurate mapping of statements and structure into object code


We spent most of the quarter learning to use the powerful open-source tool ANTLR (Another Tool For Language Recognition).  Implemented in JAVA, the ANTLR tool incorporates EBF-like (Extended Backus-Nauer Form) grammar, generating a Parser.  The parser can be used to create an AST (Abstract Syntax Tree) for a given segment of the defined language, and can perform manipulations during specific parse phases.  At the end of AU'99, we were able to translate a primitive subset of RESOLVE/C++ to JAVA source code, with subsequent compilation to executable.

Although Shawn has now graduated, I will expand on this project in coming quarters.

Completed Projects:

• Graphical Sorting Algorithms (ver. 2.0): Social Data Structures


SP '99 is dedicated to completely overhauling the implemenation of our sorting-algorithm visualization. Whereas previously we had relied on individual algorithm classes to include calls to the visualization class, we want to create modified object types that "announce" certain manipulations, state changes, etc. The advantage here is that the algorithm classes can remain compact, and only at the conceptual level, while the division between visualization and implementation is still maintained. We will again be using Java, but some elements will resonate more with the discipline maintained by RESOLVE.

In May'99, Sarah Waterson and I presented our findings at Denman Undergraduate Research Forum.  Sarah continues her work to animate sorting algorithms, extending the project in the form of an Honors Thesis.
 
 

• Graphical Sorting Algorithms (ver. 1.0): Separating Visualization from Implementation in Java


I signed on to this project specifically because it used Java, a language I had not previously used. Colleagues Brad Penoff, Tyler "the Wizard" Neylon and Sarah "Chief" Waterson started on small Java exercises from Paulo Bucci and moved towards implementing a visualization of different sorting algorithm. Our main concerns were with the flexibility of the interface, efficient structural division and the reusability of our code.

My specific focus was coding the different sorting algorithm "engine" classes: SelectionSort, QuickSort, MergeSort, BubbleSort, etc. I also built the mysterious FateSort, which relies on random repositioning of arrayed data: low in immediate practical applicability, but effective as a pedagogical example, and in situations where the definition of "order" is unknown or non-linear.

Our implementation was functional, but because the engine classes were required to make certain calls to prompt visualization changes, it did not maintain simplicity in algorithm codes. Our new focus is to allow students to work with, on the one hand simple algorithms and on the other hand, manipulable animated visualizations. This prompted a new branch of the project.

Questions that arose in version 1.0: are we dependent on linear definitions of order? what metrics for sortedness are best: # of position changes, time, "Big-O" mathmatical delimitation? how do we set a unit "step" in a given algorithm? recursive algorithms?

Return to Europa