Gnome:Daily Updates

From Notes

Revision as of 20:46, 5 August 2010 by (Talk)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search


June 7, 2010

Today, we worked on deciphering the Dasher drawing model. This will be useful because we are considering a training solution where the user is provided with an arrow pointing to the next letter they should type if they get off track. We also requested a bit more information on Dasher's architecture from Patrick.

June 8, 2010

Today, we came up with a project plan to incorporate game mode functionality into Dasher using a clean, general purpose interface. We also attempted to compile Dasher using Patrick's advice. While we did come closer to a successful build, there are still errors that need to be worked around.

June 9, 2010

Today, we set up our git repositories in such a way that one repo pulls from the GNOME git and publishes the changes for our individual repositories to pull from. Having only one person grab things from GNOME just makes the workflow simpler for everyone else. We also established the majority of a project timeline.

June 10, 2010

(Timeline: get code to compile; Remove all existing game mode code)

Today, we updated our project plan. We also came up with the basis of an algorithm for directed arrows on the Dasher canvas. We spent a considerable amount of time attempting to compile Dasher, but ran into a number of problems.

June 11, 2010

Today, we COMPILED DASHER!....on Julian's Fedora install. This leads us to believe the problem lies in the outdated libraries available for Debian Stable.

June 14, 2010

Today, we attempted to enable the preexisting game mode code in Dasher. Though we successfully got the program to draw a static arrow on the canvas, it was clear that the existing code was incomplete. We have now begun work on a class, similar in architecture to InputFilter, that encapsulates all of the game mode logic.

June 15, 2010

(Timeline: understand current dasher architecture)

Today, we began integration of the dasher game module into the core dasher code. We are working out a few kinks in compilation. We are planning to investigate setting up a nice test suite tomorrow. We also emailed Patrick about dasher architecture again.

June 16, 2010

Today, we continued creation of the game module by working around our recurring build issues, writing a modular system to abstract away the details of generating target words. (This is so that if someone were to want to generate words for training based on some complicated metric, the game module doesn't have to care about the difference at all.) Began trying to learn our way around google test.

June 17, 2010

Today, we successfully hooked the game module into Dasher's event handling and canvas rendering systems. We also continued work on the game module and word generator classes. We are still being hampered by some strange build issues, but have a decently effective workflow in place.

June 18, 2010

(Timeline: Design new dasher architecture)

Today, we managed to get things drawing to the screen and worked out kinks in getting event data. However, there's still issues to be worked out because the already-implemented arrow drawing function does not seem to work as we intended. Also, we began re-architecting the event system to support subscribing to only specific events.

June 21, 2010

Today, we got an arrow drawing to the correct letter and Julian found out we were sending out hundreds of new events each second with text draw, which makes sense, but this is a large number in terms of the overall application. Now our next hurdle in terms of game logic is ensuring we're only pointing to characters drawn on the right-hand side of the screen. (Where users have not selected them yet.) Progress is being made on converting the event system to a subscriber-based system. It's a trivial change and would have been completed today had Ryan's attention not been split between writing it and setting up a VM on his laptop.

June 22, 2010

Today, we continued work converting the event system to a subscriber based model. We also started working on logic to make the pointer arrow choose its direction more intelligently. Ryan successfully installed Fedora on his laptop, which means that soon, we will both be able to compile independently.

June 23, 2010

Today, we designed our presentation for tomorrow and participated in the CPath focus group.

June 24, 2010

Today, we practiced our presentation skills. We now have dasher compiling on both of our lapotps without much of a hitch. The event system is complete and we are now thinking of new visual ways to alert the user of a target in game mode. Some considerations have been a box or a diamond as a crosshair-like indicator. Tomorrow we will focus on making whichever indicator we decide on choose nodes more sanely.

June 25, 2010

Today, we implemented a crosshair indicator to point to target letters. Though there are still issues to work out, we successfully made the crosshair follow letters sequentially through a training text. We are currently continuing to familiarize ourselves with Google Test, and plan to run unit tests on our new event system within the next week.

June 28, 2010

Today, we attempted to compile basic unit tests against the Google Test framework. We also continued work on the FileWordGenerator abstraction layer.

June 29, 2010

Today, we packaged Google Test with our project, nearly completed the file loader and designed a more logical event handling structure to implement tomorrow.

June 30, 2010

Today, we made significant progress on FileWordGenerator, and successfully used it to feed a training text into game mode. We also began (and nearly finished) converting the event handling system to a queue-based implementation. Quite productive today.

July 1, 2010

Today, we completed the new-new event system, greatly simplifying the architecture. We still need to try to make the legacy code take full advantage of the new system, so we can finally drop the weight of backwards compatibility. We also investigated the issue of Dasher using slightly different characters at times for display and for things like adding text to the editable box at the top of the screen.

July 6, 2010

Today, we finally integrated google test into our build process. We will begin thoroughly testing what we have written tomorrow. We have also begun trying to use artifacts of the old game mode code to flag nodes throughout the model that form the path to typing the game target string.

July 7, 2010

Today, we nearly finished writing code to flag nodes along the game mode target string's path. We also began writing unit tests for the new event system, and have already uncovered bugs in the process.

July 8, 2010

Today, we continued work flagging game nodes, and ran into some problems working with the legacy game mode code. We also wrote more unit tests for the event system and added some for FileWordGenerator as well.

July 9, 2010

Today, we encountered a really, really nasty segfault. It occurs on most runs on Ryan's computer, but not very often on Julian's. Not only that, but Julian's ice cream was melted when it came out of the machine. Troublesome day...

July 12, 2010

Today, we fixed the segmentation fault that was wasting a ton of time last week. We learned about Java servelets. Julian investigated adding UI elements to dasher, which seems like more indirection work than we thought. Ryan investigated why node tagging does not work and has almost isolated the problem.

July 13, 2010

Today, we continued work on node tagging without much success. We also refactored the word generation API, as well as some of the internal workings. In addition, we successfully added a "Game Mode" menu item in GTK and registered it with an event listener.

July 14, 2010

Today, we added more documentation to the event system and streamlined the process of subscribing to individual events. Work continued on the "Enable Game Mode" menu item, but ran into problems trying to dispatch events from the GTK system to DasherCore. We also created our presentation for Friday.

July 15, 2010

Today, we met with Michael Gorse and Bryen Yunashko from the Gnome Accessibility team! Overall it was a very productive meeting and we learned more about accessibility as well as ATSPI.

July 16, 2010

Today, we made game node tagging work. It's great. We also gave our presentation for the 2nd time. It was much better than the previous iteration. Lastly, we can now toggle in and out of game mode!

July 19, 2010

Today, we solidified the idea for approximating the positions of letters that have not been drawn. Users still need directions to these nodes. Game node tagging now occurs in the model as a formal search function. We created dialog boxes to turn game mode on and off. An option for specifying target text files is in development.

July 20, 2010

Today, we discovered the root of our build issues, and successfully compiled in the HFOSS-Dasher directory. Some more work was done on UI and node tagging issues, but most of the day was spent grappling with autotools.

July 21, 2010

Today, we made significant progress on the UI. The user can now select any text file on their computer, and play game mode using its content. We also developed an algorithm to approximate the position of nodes have not yet been drawn to the screen. Ryan had to re-build his VM because its disk image was not large enough.

July 22, 2010

Today, we nearly completed all the functionality to allow game mode to be enabled, disabled and restarted. Also, the node approximation algorithm is implemented, though not quite correctly yet. There are still issues with the dasher model structure.

July 23, 2010

Today, we continued work on the UI and game node tagging. We also froze a branch on Ryan's GitHub to a stable version of our latest work.

July 26, 2010

Today, we tidied up our presentation and practiced it a bit. We're getting close to a better display of the game mode target and node approximation may be complete after tomorrow.

July 27, 2010

Today, we got the improved game mode target display up and running, complete with individual letter highlighting. Work continued on node approximation, but more difficulties were encountered working with the dasher model.

July 28, 2010

Today, we spent a lot of time practicing our presentation, and discovered some significant performance issues in Dasher. Julian installed FFMpeg so we can convert our screencasts to a format that can be edited in Final Cut Pro.

July 29, 2010

Today, we resolved the performance issues that were discovered yesterday - turns out the file IO caused by all of our logging code was the culprit. We also made some refinements to the UI and created screencasts for the presentation tomorrow.

August 3, 2010

Today, we integrated default game mode texts into the application as well as the build process. A strange smelling leak from the air conditioning vent forced us to end the day much earlier than planned.

August 4, 2010

Today, we solved some issues with the Gtk interface, cleaned up documentation, and attempted to clear the editor text when game mode finishes.

August 5, 2010

Today, we successfully made the editor text clear at the end of game mode. We also fixed an issue with the game text file dialog not closing, and updated our high level developer documentation.

Personal tools
NSF K-12