My dad and I drove down to Duke this morning and arrived at Duke early afternoon. After moving in, I started to unpack and took a moment to briefly relax before meeting with Professor Rodger later in the afternoon. We discussed new features that I will potentially be implementing in JFLAP later this summer, and other tasks that I'll be working on.
For the next couple of days, my primary focuses will be creating my website/blog (this!) and reading research papers/publications of interest and relevance. I'm incredibly excited to learn more about the various computer science topics that JFLAP encompasses, from algorithm visualization to formal languages to software design!
previous day | next day | return to calendar
First full day! I'll be working in an office in the North Building with Ian. We actually already know each other from TA-ing CompSci 6 as well as having two CompSci classes together, all last semester - it's a small world indeed!
I began the day by taking a couple of hours to set up this website using what I had started working on last night. My immediate priority was to just get the site up and running, and to take the opportunity to review some basic CSS, but I hope to spend a little time over the next few days reading up on some more CSS and putting that into practice as well.
I spent most of the remaining time reading and taking notes on two papers about JFLAP co-authored by Professor Rodger: "A Visual and Interactive Automata Theory Course with JFLAP 4.0" (2004) and "Turning Automata Theory into a Hands-on Course" (2006). Since I've taken the course using JFLAP, I was already familiar with many of the features being described, but it was fascinating to read about the progress of JFLAP's development and realize that many of the features I had used extensively just this past semester were newly added at the time the paper was written.
I also decided to find other finite automata theory software to explore, and came across the Finite Automata Tool (FAT). I liked that it showed the formal definition of an automaton explicitly, but missed JFLAP's user interface and the better visuals and drag-and-drop functionality (and ability to save an automaton you create). One thing FAT does offer that JFLAP (currently) doesn't is the ability to find the complement of a Finite Automaton or the union or intersection of two FAs - this really reinforces the idea of sets being an underlying concept behind FAs, which is part of what I may be working on with JFLAP later this summer.
previous day | next day | return to calendar
I decided to start off the day by learning more about the Cocke-Younger-Kasami (CYK) parsing algorithm. While this topic was mentioned in one of my CS 140 textbook readings, we hadn't actually studied how the algorithm actually worked, which I was quite curious about. I started off by, of course, reading the Wikipedia article on the CYK algorithm to develop a feel for and gain some general understanding of the topic. Although an genuinely interesting read, parts of the algorithm went somewhat beyond the scope of what we had studied in class, for example determining the worst-case run time. I thought it would be useful to read a different explanation and work through a couple of small examples myself, so I found some notes from a Western Michigan course with a worked example that I tried doing with paper and pencil, which I found really useful in better understanding the algorithm.
Afterwards, I started reading the Software Visualization: Programming as a Multimedia Experience book edited by Stasko, Domingue, and Brown. The first chapter, "Introduction to SV" was a surprisingly fascinating read, and although the material was very dense and referred to many example systems I have never heard of, I really enjoyed getting to read in more detail about what exactly Software Visualization encompasses. This chapter provided a number of definitions from SV literature and discussed in relative detail the six categories of SV: Scope, Content, Method, Form, Interaction, and Effectiveness, and in turn discussed various subcategories of each of those using tree diagrams to show how each category could be broken down and organized. At first I tried to take notes while reading, but given both my propensity for copious note-taking and the amount of detail and important/interesting information, I decided to just read to absorb and appreciate the knowledge.
While reading, I was very surprised to find out just how large and diverse Software Visualization is. This was my first time formally reading about it, and I had assumed it was mostly tools like JFLAP that helped students understand algorithms and programs in an educational or academic setting. However, SV is also used in industrial settings like AT&T and IBM, and in software engineering. Computation/Performance Visualization helps visualize hardware performance, whereas I also assumed SV literally referred to higher-level algorithms or code. Since this book was published in 1998, it's interesting to see how many of the goals discussed in the Future work section have come to fruition since, such as more empirical evaluations of SV effectiveness, the progress made with increasing scope, and the development of interfaces for visually impaired programmers (mentioned in passing at the end of the chapter).
Today was also Julian's first day; he will be here working with Ian and me for the next month. He's been doing research with and developing JFLAP (from code refactoring for better design to adding new functionality to improving the user interface) and has asked me to help him test various changes he's implemented. I tried a variety of features, from converting from a PDA to a CFG and from a Right-Linear Grammar to a Finite Automaton to testing LR and brute force parsing, and found some bugs with various features which I documented. However, it's very apparent that Julian's put a lot of effort into improving JFLAP and I'm really excited to see it continue to come together in the upcoming weeks!
previous day | next day | return to calendar
I thought it would be interesting and potentially useful to learn about Moore and Mealy machines today, and started off with that. I've noticed these on the JFLAP option menu for a long time although they weren't covered in class. After reading the Wikipedia (of course) articles for the Moore and Mealy machines, I looked at some additional notes and examples from the JFLAP website and experimented with the machines in JFLAP to further my understanding of Mealy and Moore machines and how they differ. The vending machine example of a Mealy machine was interesting to see; even though I've actually seen a similar problem in my Discrete Mathematics class, it was treated as a finite state automaton and I didn't know at the time that a machine with output has an actual name.
I did some additional readings during the later morning and throughout the afternoon, including Chapters 2 and 3 of the Software Visualization book, "History of SV" and "A Taxonomy of Algorithm Animation Displays," respectively. Chapter 2 discusses the maintenance challenges posed by increasingly complex software programs that no person any longer fully understands but upon which people are increasingly dependent, and the need for software visualization to enhance program representation, presentation, and appearance; it briefly describes a number of earlier SV programs and how they each present source course, diagram control flow and data structures, and animate program behavior. Chapter 3 describes three dimensions of algorithm visualization: content, persistence (current state of information vs. complete history of changes), and transformation (discrete vs. incremental and continuous changes) using figures illustrating various sorting algorithms to show examples and comparisons for each dimension.
I read a short paper, "Changes to JFLAP to Increase its Use in Courses" (Rodger, 2011), which summarized several new features added to JFLAP that were demonstrated at a session where this paper was presented. I also read "Experimenting with formal languages using Forlan" (2008) by Alley Stoughton, the creator of Forlan, a strongly typed interactive language based in Standard ML; like JFLAP, Forlan allows users to experiment with a multitude of topics in formal languages, but mainly differs in that it is language-based rather than graphically-based. Although Stoughton cited the advantage of the former because they allow more sophistication than graphical programs, I think tools like JFLAP are still useful because from personal experience, I can really attest that being able to clearly visualize concepts really enhances understanding. Even if both JFLAP and Forlan's purpose is to allow hands-on experimentation with formal language examples that would be too tedious to solve by hand, I get the impression they differ slightly in their approach, visualization versus allowing efficient and sophisticated experimentation.
Otherwise, I spent a little more time updating my website/blog, and looking for set theory tools online. I found one with a somewhat promising name but the applet was unable to download properly, and I have yet to find matches that look relevant. Indeed, as Professor Rodger warned me and I predicted, "set" is not an easy word to Google, even with a number of modifiers (e.g. "computer science set theory software tools").
previous day | next day | return to calendar
Today, I read the paper "Fifty Years of Automata Simulation: A Review" (Chakraborty, Saxena, and Katti). Many of the readings I've done until this point have been at least several years older, so I strongly appreciated having a very recent (2011) overview of the different automata theory tools that are available today. It was incredibly eye-opening to learn about the different categories of automata theory tools, and how Language Based and Visualization Centric in turn span several subcategories. Since most of the tools naturally include a similar set of features, it was rather difficult to discern from a paragraph summary, without actually having extensively used each tool, the main advantages and disadvantages of each, though. However, I definitely loved reading the accolades the authors gave JFLAP, essentially deeming it the best automata theory tool of the day! While I know from personal experience that JFLAP is a highly versatile and helpful tool, it's exciting to see that there are others who also regard it very positively, and I definitely look forward to the challenge of making it even better!
For lunch, Professor Rodger treated Ian and me to lunch at Dos Perros, a Mexican restaurant located in downtown Durham. Having never actually been to the downtown area, I enjoyed the opportunity to venture there for the first time and loved how scenic it was! We also had some great conversation including about various courses and professors in Duke's Computer Science department - it's always fun and interesting to hear about these topics from a professor's point of view in addition to other students'.
Another paper that I read is "JHAVÉ: Supporting Algorithm Visualization" by Thomas Naps, which focused more specifically on Algorithm Visualization (AV). It was interesting to read about although excellent animations and computer graphics were valued and praised by professionals, they weren't necessarily beneficial for students actually learning the material, and more engagement and exploration with the visualization is needed from a pedagogical standpoint. Having not known much about the field prior to reading this paper, I had naively assumed that having top-quality graphics should automatically enhance the learning experience, provided one was at least somewhat of a visual learner and the graphics were relevant and logical to follow, but I hadn't actually considered that having to navigate complex nuances could detract from gaining an initial understanding of the algorithm. Naps discusses the extensibility of the JHAVÉ framework and what one needs to subclass and override to properly use it. After taking a Software Design course, I definitely appreciated reading about this design aspect and seeing flexible design discussed in practice! Although JHAVÉ didn't sound like it was widely used yet, I really admired the concept and its underlying motivations in computer science education.
The main priority for the next couple of weeks will be helping Julian debug JFLAP 8.0 so that it will be fully functional by the time he finishes. I sent him a list of various problems I discovered a couple of days ago, so I need to check in with him to see whether any have undergone changes already and are ready for retest.