Monthly Archives: October 2017

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

Magic Item Generator

Language Used: C# WinForms

Skills Used:

  • Practice Designing User Interfaces and their Functionality
  • Writing Generated Data to a File
  • More Practice with the C# Language

Project Overview:

This project started as an idea from a friend. He was running a Dungeons and Dragons group I was apart of and was talking about how he wished there was an easier way of creating magical items for his games, since it took about 5 minutes to generate one magical item. I offered to create him a program that, given a couple parameters, will generate him a collection of magical items. He was interested, and sent me some lists of possible items, enchantments, and other details I needed.

Current Progress: User Interface Designing Complete

As of now, the program’s interface has been made and been approved by my friend. The next step is to wire everything up to make it functional. First step will be Enabling/Disabling UI components as they become usable/unusable. For example, he shouldn’t be able to generate items if the number of items isn’t given. Once that step is done, then it will be the main process of the program, of generating such items and displaying them to the output.

The next steps to this project is the implementation of the program, setting up the logic behind it all. Setting up the randomization and displaying the data I don’t think will very hard to implement. The area in which I want to challenge myself is how to store in all the data for the different types of possible items and their descriptions. I debating between two different ideas for their implementation: a database for each major group of item, or multiple different enumerated types. As of now, I’m leaning towards a database being the most ideal solution to this problem, but I have never used enumerated types before, and this project might be a good introduction to learning them.

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.


Hello, and welcome to my website!

I’m Michael, and I’m an alumi of Eastern Washington University. I’ve learned about all different kinds of programming languages and techniques during studies as an undergrad, and continue to learn after graduation. Eastern gave me the tools to start developing, but it’s up to me to continue to grow those skills. While my career as a developer is definitely helping my skills grow, there’s nothing better than making my own ideas come to reality.

This website is a place for me to share different programming projects I have made in my time developing. Some of these projects have been personal projects, requests made by friends of mine, or some cool assignments I’ve worked on back in college. Some are a work in progress still, but I find that sharing the development process can be much more interesting than simply a summary of the finished product as it allows me to show my thought process throughout the entirety of development.

Anyways, I’ll stop rambling on introductions now. Thanks for taking the time to read these posts, hopefully you can learn something new from them. 🙂

– Michael