Engineering Notebook Aaron Van De Brook

Engineering Notebook

Specific Events

11/30

• Finalized last changes to the last two open issues
• Added styling to graph templates to make the images easier to read

11/24 - Standup

• Did: System to automatically run dot on the graph, fixed some bugs that were showing up in the graph
• Doing: Filtering logic, graph styling
• Next: IEEE Paper

11/24

• Reworking the filter functionality, filter expression is now more stable and can be used more consistently with other commands (order does not matter any more)
• Changing filtering logic so that it actually follows the source -> destination form
• Filtering outline:
  1. Filter by module first
  2. Then filter by edges whose source and destination match the form above and the expression entered

11/23

• Fixed problem that was causing extra node. Might be a bug in doxygen (?) the __attribute__ compiler directive was showing up as a function for some reason, might just be a difference between the arm-none-eabi-gcc compiler and normal gcc/clang compiler
• Also fixed problem that was causing "internal" connections to show up even after they were removed

11/17 - Standup

• Did: Finished graph writer, published documentation
• Doing: Fixing issues with how the image is rendered (~3 issues so far)
• Next: Filter functionality, automatic image render, test cases, paper

11/17

• Published javadocs to GitHub pages
• Merged GraphWriter

11/13

• GraphWriter is done and works reliably. There is thorough documentation throughout the class as well as an explanation as to its purpose at the top of the class.
• Revealed following problems:
  • Problem with image dpi, image tends to tear when the graph is too big (this might be fixed by using vectorized image formats, not sure though)
  • __attribute__ node is ignored in the parser, but never deleted. As a result it is showing up as what I am calling a rogue node (rendering outside the other modules, doesn't belong or point to any modules)
    • Problem might that there are edges which point to the __attribute__ node for some reason
  • Need to implement module filtering ({ModuleA, ModuleB} -> {ModuleC, ModuleD} to help verify the dependencies in the graph)
  • It seems there may be some edges that are pointing to nodes within their modules (not positive, this needs to be verified in some way)
    • The graph is so big that there are several edges getting drawn over each other, which makes it hard to be sure whether some "internal" functions are pointing to each other

11/12 Standup

• Did: GraphWriter - Set up template system and enough to get an initial graph image generated
• Doing: GraphWriter - Setting up edge definition generation
• Next: Some kind of class/script to automatically run dot on the graph that was created by the GraphWriter (ascii text file)

11/12

• 4/5 of the steps for GraphWriter are done. Need to make sure that node IDs vs node labels won't cause problems when creating the edge definitions
• Today I discovered Java Streams and eliminated 2 for loops
• Completed edge definition creation. Here's what's left to do:
  • Add javadoc comments to GraphWriter
  • Automatic image rendering system
  • Fix problem with node creation
  • Fix __attribute__ edge case
  • Module filtering (inclusively and exclusively)

11/10

• GraphWriter notes:
  • Modules are organized into subgraphs, functions within those modules are organized into public/private function sections, which are implemented as subgraphs within the aforementioned subgraph (yes, that's valid)
  • Thinking of taking a step-by-step approach (this will make it easier to think of instead of thinking about everything at once):
    1. Write graph with only public subgraphs of each module
    2. Write graph with public and private subgraphs
    3. Write graph with public and private subgraphs contained in their module subgraphs
    4. Write graph with modules and connections
    5. Add in styles to make graphs more readable (and prettier, e.g. font families, font sizes, node shapes, etc.)

11/06

• Set up basics of the GraphWriter class
• Need to come up with an order of operations to setup each portion of the graph

11/05 - Standup

• Did: Configured Javadoc settings and generated Javadoc web pages
• Doing: PR needs to be approved, then add pages to the repo web page (github.io)
• Next: GraphWriter design/implementation

11/05

• Javadoc does not document private or protected functions in normal classes
  • Need to set Gradle's options.showAll() option to document private/protected functions and attributes

10/29 - Standup/Demo

• Did: Created flowcharts for most of the functions in the project
• Doing: Generating graph images and creating wiki pages for them (will link individual nodes to other graphs eventually)
• Next: Sprint 3 planning, Designing GraphWriter

10/29

• Fixed case sensitivity when creating and adding nodes to modules
• Generated images for graphs

10/28

• Created graphs for major functions in the project.
• Minor functions (like search functions) still need graphs, but they almost all do a variation of a linear search algorithm

10/27 - Standup Meeting

• What I did: Wrote code to split nodes into modules
• What I am doing: Writing up graphical documentation
• What I am doing next: Sprint demo presentation

10/23

• Created module class, wrote some code to split nodes into modules.
• No other problems encountered.

10/22 - Standup Meeting

• What I did: Effectively finished first version of Parser. Now reads every file and creates corresponding nodes and edges.
• What I am doing: Documenting the "flow" of the project, basically creating flow charts for each class/function, so it's easier to pick up on what it's doing. Grouping nodes in respective modules.
• What I am doing next: Figuring out how to write test cases for the Parser.

10/20

• Manipulator Design:
  • Separate nodes into module in parser
  • Decided to delete the manipulator class and re-distribute its job(s) into parser
• New parser responsibilities:
  • Check for duplicate edges/nodes, before adding nodes (edges?)
  • Separate into modules (based on module prefix)
  • Trim "internal" connections

10/20 - Standup Meeting

• What I did: Refactored Parser, added story cards to reflect what we need to do for sprint 3, identified problem with how Nodes are connected, added detailed documentation to every class that we have finished or are actively working on
• What I am doing: Fixing the issue mentioned above
• What I am doing next: Working on manipulator module

10/16

• Idea to fix the previously described problem: store a collection of Node objects, when an edge object is created, link it to the two Node objects
  • Potential problem with idea: sometimes a node is created, then and edge with a reference to a node that is created afterward, this can lead to null pointer exceptions.
  • Check if the both nodes have been defined when creating a new Edge, if one isn't then skip the link for that Edge and fill it out at the end of the function before it returns.
• Added as much documentation as possible in the current state in the project. Identified possible bugs if attribute lists aren't present when we try to process things like the function label.

10/15

• Parser class mostly finished, trying to figure out the best way to store node and edge information
  • Changed return type of parse function to void and storing Node and Edge objects as class attributes, which can then be retrieved by calling context
• Created an Edge class represent connections between nodes
  • Potential problem with how Edges handle connections: they only store the node_id, not a reference to a specific object, if 2 node_ids exist for the same function there will be problems when trying to process the graph into the end result

10/04 - 10/12

• Created Lexer Class
  • Ran into troubles with Enumerators and Strings
    • Corrina fixed the Enum problems, used char arrays and Arrays utilities to fix string problems
  • Class reads files one line at a time, and matches specific statements char by char

9/27 - 10/8

• Finished polishing code from sprint 1. Started designing Parser, Lexer system
• Can't figure out what tokenize and how or how to pass information from the Lexer to the Parser
  • Created a Token class to store the token type and value of the token, returns from Lexer once it is done tokenizing a line

Things I am Doing

• Managing Gradle and the overall GitHub repository settings
• Designing and coding modules along with the rest of the team
• I also prefer using Linux (Ubuntu) over Windows, so I am figuring out some of the oddities of getting Java projects running on Linux
• I've also been working with the phxbms code for nearly 2 years now, so I have a wealth of knowledge about the modules, how they interact, and how Dr. Liu wants to change them

Things I've Learned

• How to set up and use the Gradle build system in a project (and in an IDE other than Eclipse)
• How to integrate JUnit into a Gradle project on both Windows and Linux
• AdoptOpenJDK provides Java binaries that are relatively easy to use and install that are also an easy way to migrate from Oracle's JDK to an open source version