Category Archives: Completed

PC2 Contest Data Package Tester

Language Used: Java

Skills Used:

  • Development with JavaFX and other third-party libraries
  • Communicating with our client and meeting their requirements
  • Working with a team of programmers on the same project and dividing up the work evenly.

Project Overview:

This project was my final project as an undergraduate in college. My team had about twenty weeks to develop a piece of software from start to finish. The projects available were presented to us within the first week, which were real projects requested by people or companies. My project is know as a Contest Data Package Tester, requested by the developers of the Programming Contest Control (PC2) system from California State University, Sacramento. We communicated with the lead developer on their team, and received a project overview for what this parser actually was.

The PC2 system is a collection of software used to host programming contests. Different teams use a client to connect to a central server, and will be given a collection of programming problems to develop under a certain amount of time. When judges are preparing the contest, they have a large collection of input data for problems and need to ensure the output of that input is what’s expected. They’d do this by running a mock contest and test these problems one at a time. This was an incredibly tedious and time-consuming process. That’s the problem our software aimed to solve, where we would provide the user with a method to select problems to test, and visually see the results from testing, simplifying and speeding the process.

Project Status: Complete

Despite our short time frame, we managed to complete the entire software on schedule. I’m incredibly proud of this software, since so much time and effort went into it, along with our client being pleased with the end result. There was a lot that I could take away from this project, but there were some key aspects that I could take away from it.

When we began the project, we spent about a month designing and fleshing out the entire program before writing a line of code. We put a ton of time into the design phase, creating our user interface and our software’s architecture, that when it came time to begin coding, we knew exact what had to be done. This was incredibly helpful, as we were able to solve a lot of the problems of our design before getting to deep into it’s implementation and spending too much time refactoring. Before this project, I never took as much time into the design phase as here. Most of my design was just create a list of features that I wanted to implement and go from there. However, this taught me that by creating a good design beforehand, a lot of the problems can be resolved before even encountering them.

On a more technical level, I’ve become confident in my abilities to work with JavaFX. Before starting this project, I knew nothing about JavaFX, as all my GUI programming was either web-based or in C#. After going through some tutorials and trial and error, I got familiar with the technology. I began to recognize reoccurring issues and how to solve them, how to work with multiple threads alongside the UI thread, and even creating custom FX components to extend the functionality of the pre-existing components. This technology went from one I knew nothing about, to being the one I’m most confident in, which just goes to show how much can be learned about a technology the more you work with it.

Overall, this project was fantastic to work on, and by far one that I’ve learned a ton from. I find myself going back to this code for reference, as a lot of the issues I’m encountering in other projects I’ve already solved here. Sadly, I cannot share the source code for this project, contracts and such, but the knowledge that I was able to take away from developing it is something that will definitely help in the future.


File System Watcher

Language Used: C# WinForms

Skills Used:

  • First Exposure to GUI Programming.
  • Working with the FileSystemWatcher class in C#.
  • Working on multiple thread and communicating between them.
  • Working with SQLite within a program (Creating, Inserting, Querying, and Deleting).

Project Overview:

This was my first true project working with GUI programming, which also happened to be a project for one of my classes. We were to utilize the FileSystemWatcher class built into C# to have the user specify a extension to watch, along with the root directory to watch from. Our program, when running, would then watch for any files or directories (depending on what extension the user wants to watch) that are created, renamed, changed, or deleted within the root folder or any of it’s sub-directories. Once the user stops watching files, and there has been some changes recorded on the output, the user will be able to send those entries into a Database file. Once that file is in existence, they’ll be able to pull up a second form and perform queries on the database file, specified by what extensions they want to see.

Project Status: Complete

This project was extremely fun to work on, for it was involving a lot of aspects/topics of programming that I have never dealt with before. It challenged me on what I knew, and required me to research different topics to be able to implement them, like WinForms, communicating between threads, and SQLite to name a few. Once the project was done, it was satisfying to have an actual interface rather than everything being text-based. It was a nice change of pace, and motivates me to create more GUI-style programs, or porting older assignments to have an interface.

I tried to make the interface as intuitive as possible, so someone with no programming experience would be able to use the software with ease. All the possible options activate and deactivate as they become valid. For example, in order to have the “Start” button active, the user must have specified an extension (or all files) and a root directory, only then will the button be active. I also added in a third form to house the software’s instructions, in a nicely formatted fashion. This was a better solution to showing the instructions than in a MessageBox, where there is much more limited formatting.

Overall, this project was a lot of fun to work on. I enjoyed learning about all the tools that WinForms have available for GUI development, and how to have them behave in the expected manner. Threads were another interesting topic that we covered while working on this project, and how to properly have threads communicate with each other using delegates. I learned a lot from doing this project, and I’m looking forward to whatever my next GUI project may be!

Online Dictionary

Languages Used: HTML, CSS, and JavaScript ( jQuery )

Skills used:

  • Researching for different available APIs around the web.
  • Using AJAX requests to APIs to ask for data about our given input.
  • Processing JSON and XML formats to extract needed data.
  • Displaying received data in a presentable way.
  • Tons of practice with CSS

Project Overview:

This project was an assignment in my Web Dev class, where we had to find a collection of APIs to find different attributes of a user-inputted word. We had to find APIs for the word’s Definitions, Synonyms, Antonyms, Anagrams, and Translations. We then had to take those APIs, create AJAX requests to each of them, and display their output back to our user. This allowed the user to input a single English word, and get back a lot of information about the word they entered in. Another section of the project was to find an API that would take in a sentence from the user, and return back the sentence in “Yoda Speak”.

Project Status: Complete

This project took a lot longer than I expected it to take to complete. I didn’t realize how difficult it would be to find these APIs that didn’t require any payment in order to use. After many searching and exploring different APIs, I found 4 of them that could do everything that was required for this project. Working with the APIs was pretty fun too, some of them would return back in a JSON format, making them pretty easy to work with and extract the proper data. One of them returned back XML, which took a decent amount of time to learn how to process that file.

Once I got all the requests handled, laying them out onto the page was the next big step. I went through a couple of ideas, displaying everything in a single textarea element, to using multiple textareas for the different parts, but I finally settled on using 5 tables for each of the words components. The reason for that decision was the ease of reading the data. In the textareas, they would all be formatted strings, using indentation to give the appearance of lists. Overall, it didn’t look very polished. As I was working with some classmates on the assignment, one of them showed me how they laid out their data, using 5 different tables. It looked so much cleaner than how mine was looking, so I reworked my display to work with tables instead. Using a bit of jQuery and CSS, the data is much more readable than the original textarea idea I was going with.

Finally, was designing the page to look much better than a bunch of tables on a white page. Honestly, the designing of the page probably took just as much time as making the functionality of the page itself. I wanted to incorporate a “sidebar” onto the page, to allow users some navigation between the different assignments in this class. Getting that setup took forever, trying to figure out how to position different <div> tags and modifying them to only display in a certain area. Once that got finished, I tried testing it on my laptop instead of my desktop, and the entire page was wrong! The different boxes I spent so much time getting to the right spots were now overlapping, text going over the user’s data, it was just a mess. I didn’t account for different screen sizes when I initially was designing the page, so I ended up adding in some more Javascript to set the boxes to a factor of the display’s size. That fixed the problem I was having, and with a little more work a touch-ups, the page eventually reached a point where I was satisfied with how it looked.

Overall, this project was a really good learning experience with the different web tools available to developers. It’s fantastic to know that these APIs exist out there, so developers don’t have to go and rewrite and entire program every time they want to implement a dictionary or translator to their page. It was also a fantastic learning experience with CSS, for now I know a couple of new tools and methods that can help with future webpages.

Link to Project

Dungeon Battle Simulator Project

Language Used: Java – Console Based

Skills Used:

  • Use of a collection of Design Patterns
  • Saving/Loading program state using Serialization
  • Debug using Beta Testers

Project Overview:

This project was a final project in one of my classes. We were given the source code of a program that would simulate a battle between heroes and monsters. We had to modify the code to utilize a number of different design patterns. We had to use the Factory, Strategy, Memento, Mediator, and MVC patterns within this project.
The end result was that the user would be able to have a Hero group of a specified amount, choose all their classes and names, and fight an equally large group of Monsters. The first group to run out of group members, loses. The user would also be able to save a battle to a file, and reload to that point from the main menu. Overall, it was a huge assignment, but I learned a lot from it.

Project Progress: Complete

This project took a fair amount of time to complete. It ended up being built across 19 different files, each with a different purpose. I thoroughly enjoyed this project, for it taught me a lot of different techniques for approaching different problems. The hardest part of this project I would say would of have to be the debugging progress of it. While the different tasks were rather easy to code and wire into the project, finding all the small bugs that would arise was a challenge. They ranged from unaccounted for edge cases, a logic error in a rather rare case, or just a missing feature, it was near impossible for myself alone to find them all. At the time, I was living in the dorms on campus. What I ended up doing was talking to some guys down the hall to me and asked if they’d beta test a game for me. Just mess around with the game, try different things in attempt to break the game.

They all agreed to test it out, and within and hour they found a handful of bugs that I never ran into. They provided pictures of what they did to cause the problem, and I would go into my code, identity what was causing the strange behavior, and send them an updated version of the code once fixed. We went back and forth for about 6 hours, finding and fixing bugs, it was a rather fun experience. Once everything was all said and done, they all said that they enjoyed playing through the game, one of them said something along the lines of: “I would turn on some epic battle music, and imagine my group of heroes fighting off the horde of monsters. It was a lot of fun!”. Hearing that brought a smile to my face, to have some feedback from a user about how they enjoyed their time using my project. It’s a nice feeling to have when you put in so much time into creating this large project, and to have the end result be something people actually enjoyed.

The biggest takeaway for me was the different design patterns that we were required to use for this project. Each one of them addressed a different aspect of the project, and after implementing them into the project, it helped make the code much more readable and modular. Want to add a new character? Just add it’s settings to the Hero Factory and you’ll have a new hero just like that. Want to add in a new special attack to use? Just make a new special attack object and it can be wired in easily. That’s what makes this project fascinating to me, just it’s ease of adding in new features due to it’s modular design. It’s definitely something to take note of when I continue to make more projects.

Overall, this was a fun project to work on, and while it is in a finished state, I have some future plans for it to expand it’s capabilities further. One of the suggestions given by one of the beta testers was to add a separate “Gauntlet Mode”, where the user would make a team of 10 heroes, and would have to take on X amount of monster battles, increasing in difficulty. I think the idea would be a fantastic addition to the game, having different possible “gamemodes” the user can choose from. It’d be a fun challenge to implement a scaled difficulty that was fair to the user. Some other ideas I have are allowing the user to create their own custom hero class, rather than from the limited 5 that are currently available. I also want to eventually try advancing it beyond the console-based display to a graphical interface. It’s some ideas to expand onto this project, for I believe this project can really grow into something really cool, and would provide a good challenge to myself.