Skip to content
gmbrooker edited this page Apr 27, 2015 · 25 revisions

4/27/2015

Added typespecs to the modules and closed that respective issue. Also created a load_balancer behavior module that will be fully implemented once we discuss what callback functions should be utilized by every load_balancer algorithm. Some changes will need to be made to the two pre-existing algorithms to account for this behavior. Also, we're meeting as a group today to discuss what we can do to finish out the project before the version 1 release tonight, as well as what we need to accomplish for our demo.

4/20/2015

Met with the group today and recorded my portion of the video that is going on the git pages site. Joe's taking care of putting our parts together into one document, and Paul's updating the git pages site. We'll send Dr. Vidal a link to this site today for the milestone.

4/16/2015

Met today as a group and have planned out the rest of the semester. The QA-ing of the AAVRAD group has been taken care of. We're meeting this Sunday to record the video to put on our git pages site. Paul's going to update the site to help explain the project. George is close to having a draft for the research paper. That will be embedded on the git pages site once we've revised it. We plan on finishing out the coding by the end of the last day of class, 4/27.

4/12/2015

Working on QA-ing the AAVRAD group's web application. We were first able to access the website (due to an error on their part) on roughly April 7th, so I'm guessing we'll have until around the 21st to finish QA-ing their stuff, although I'm looking to finish this task within the next couple of days. I'm also going to add typespecs for dialyzer to the functions that I have written and look into what a proper log file needs to contain.

3/31/2015

Published release candidate 1 for version 1.0.0 of our repo. The RC1 is available for QA group to begin testing our simulation. Before publishing the RC1, I made some changes to the simulator architecture page on our wiki and made some significant changes to README.md so the QA group will know what they need to know to understand the simulation/be able to run the simulation. I also added our names to the LICENSE.md file.

3/22/2015

Merged my latest commits in my fork with this master repo. The changes can be seen in merge requests #40 and #45. Also, we are going to meet as a group on 3/24 to work on some changes to the source code that need to be taken care of.

3/19/2015

Met with team today to discuss what we need to implement for our next meeting with Dr. Vidal, as well as what we want to accomplish by the end of the course (and beyond). Since I made a lot of architectural changes to the source code to make it so a lot of the simulation's functionality can be spawned as processes, I'm going to probably create another branch that alters the overseer such that five or six iterations of the load-balancing algorithm are ran and each of those results are printed to csv output. Moving forward, I'm also going to focus on making it so we have a robust log file that tells us everything we need to know about the simulation and also adding dialyzer typespecs to the code. Another task on my plate is to work on creating a health-check module that will be spawned at the start of the simulator and ensure that no server reaches a certain capacity threshold as clients are spawned.

3/16/2015

Working today on updating the documentation in overseer/simulator/greedy modules. Also looking into non-implementation housekeeping-type stuff, such as adding typespecs to our code and updating the makefile to increase functionality.

3/11/2015

Met with George regarding the firstworst algorithm. After ensuring that the firstworst algorithm was ready for beta release status, I added timing functionality for the firstworst algorithm using Erlang's now() function (identical to the timer I added to the greedy module) and also modified the overseer module to add a function call to the firstworst algorithm. Merged those modifications with the master.

3/10/2015

Merged a new version of our source code from my forked repo to this repo's master. The concise list of changes I made can be found on the merge request page for merge request #35. The changes I made included added functionality for storing clients/servers globally using an in-storage memory solution ETS. I also added functionality for server capacity.

3/9/2015

Met with George and Joe regarding our beta release. Will meet back up with George Wednesday to ensure that I grasp the firstworst algorithm and what it is doing.

3/8/2015

Currently implementing ETS in my forked version of the repo. Will merge with this repo's master once the source code in my repo mimics what this version of the source code does.

3/2/2015

Still working on the implementation of the newest version of our source code. The major change in philosophy in this version is the fact that there will be a spawned master_server that handles the communication between the client/server layer and load-balancing layer. The master_server actor, when spawned, will send/receive messages from the algorithmic functions and simulator functions so it can always maintain the most recent/correct version of the server dictionary.

This implementation, along with the updated visualization provided by Paul and the new algorithm based on server fragmentation that George/Joe are working on, will be included in our 'Beta' release.

2/22/2015

Been working on implementing server capacity to our simulation. This is turning out to be much more extensive than originally planned, which I guess is the nature of the beast. Looking to make some major progress by this Wednesday. There will probably be some major changes is our simulator and overseer modules.

2/10/2015

Closed some issues today and opened others. Main thing accomplished is the greedy algorithm seems to be working as it should. The next conceptual step is to take into account server capacity.

2/8/2015

I've made some conceptual progress on what needs to be accomplished for our greedy algorithm to work. In our last meeting as a group, we assigned each other issues that we hope to have mostly done by Tuesday. I will be focusing on the algorithm, as well as changing the directory of the d3 output in our source code.

1/25/2015

We've been catching Joe up to speed, our new group member. We also met with our client over Skype this past Thursday to discuss our short-term goals for this semester. I've started working on tweaking our Greedy algorithm so it accounts for the local aspects of every server in the cluster, not just the first one.

12/5/2014

Guess this will be my last entry of the semester. Met as a team yesterday and made our slides for the demo. Also made some last minute changes to our code (namely, added a lot of documentation and made it so the overseer moves the csv files to the ../../visualization/D3/ directory). It looks like we are good to go for the presentation/demo tomorrow.

11/29/2014

Since my last edit, I made drastic changes to the overseer class. Now, the overseer keeps an orddict, or hash table, of all the servers with their {client_PID, group_ID} tuples. I added several functions to the overseer that takes care of printing the information in this orddict to a csv file that we will use in the presentation of our "prototype". I also began looking into how we can dynamically move the clients from one server to another. I believe that it will be the easiest for us to manipulate the data in the orddict using our algorithm, then running another process for the same client that pings the new server that it is assigned to.

11/19/2014

Updated the simulator to include functionality for spawning multiple servers, as well as the initial assignment of clients to those servers this past week. Also created the module Overseer, which will take care of spawning the processes that will simulate and run the algorithm. Also commented those source files so anyone can take a look at our code and understand what's going on.

11/12/2014

Completely forgot to update my log for the past two weeks, so I went ahead and did that. Also, after our team meeting tomorrow, we are going to discuss a time or two this weekend/early next week where we can all get together and finish up our simulator and continue working on our algorithm. In our team meeting tomorrow, we will focus on how we will implement d3.

11/6/2014

Had a team meeting today and now I understand what we need to do to finish up our simulator. Our simulator will essentially spawn a certain number of servers, a certain number of clients, assign each server and each client its own group ID, and just add the clients to the servers in a random fashion until those servers are of full capacity. Our algorithm, which will most likely be a member of another Erlang module, will take care of moving those clients to different Server_PID's.

11/5/2014

Met with Dr. Vidal today and discussed what we need to do within the next two weeks. We will work to finalize the mathematical description of our problem to make it more scholarly. George has the lead on that task. We will also look into using a visualization tool such as d3 to have a pretty graph of the client/server relationship that we are researching.

10/27/2014

Worked on Simulator to add a functionality where clients and servers now have their own respective group IDs. Will discuss with group to decide how we should move forward with adding a more robust group functionality.

10/18/2014

Had a team meeting yesterday and discussed with the team what we needed to do to have a tangible simulator started by our next meeting with Dr. Vidal next week. Did some research and actually found an online lab for a computer science course in Erlang on how to create a very basic server/client simulation so I think we're going to use the concepts involved in that lab as our very bare foundation for the simulator that we will be building in this project. Also pushed a rebarized version of said simulator to our master repo. Will work more on the Makefile and other housekeeping things for our repo this weekend, probably Sunday. Overall, I'm happy with the progress that we're making, even though it's pretty clear that all four of us are super busy with all of the other things we're doing this semester.

10/09/2014

Past week has probably been the most productive week our team has had. Met with each other Tuesday to finalize the mathematical description of the problem. Met with Dr. Vidal on Wednesday to further discuss the mathematical problem. He's ok-ed that portion, so now we're to move on to starting on the simulation of the problem in Erlang. Dr. Vidal wants to see something done for that for our next meeting on 10/22. As for me, I've been continuing to read through LYSE and this week, mostly, I've been researching published research papers on load balancing to get a better overall idea of the topic. We are going to meet with our client via Skype today.

10/01/2014

Spent a couple more hours reading through LYSE. Also forked our repository to my user account and cloned it to my personal computer. I'll be adding some programs I've worked on in the next couple of days. Also did some research regarding the mathematical problem. Will discuss with the team tomorrow to see what they think.

9/23/2014

Spent close to three hours this evening reading through Learn You Some Erlang and some links Drew provided for us. Along with LYSE, I also got more comfortable with using Rebar and EUnit. I read through some documentation on MQTT, a lightweight, M2M, internet of things connectivity protocol. Overall, I'm starting to get a better feel for coding simple applications in Erlang.

9/19/2014

In our weekly meeting, we went through the links Drew provided and decided to divide and conquer them for our research.

  • Everybody- Learn you some Erlang, Rebar, example makefile
  • Davis- Travis
  • George- Edoc
  • Paul- Cowboy
  • Graham- Semantic versioning, MQTT
  • We also wrote our Project Description and posted it on the wiki. We plan to plow through Learn You Some Erlang and begin playing around with our own code in Erlang just to become accustomed to the language.

9/16/2014

Met with Drew, our client/mentor, for the first time today. In this meeting, we discussed:

  • How to get acclimated with Erlang
  • The state of Erlang as a language
  • What the first leg of this project will focus on (learning Erlang, version control, learning best practices for documentation and testing with Erlang)
  • The overall purpose of the project: to create an applet that will manage and maintain load balancing across multiple computing resources
  • Overall, thought the first meeting with Drew was very successful. He was added to our repo under his request so he can provide guidance whenever need be. Now that we have met with our client, our group meeting this Thursday at 6 will focus on completing Milestone 4.

9/14/2014

Our group will meet with Dr. Vidal every other week starting Wednesday, September 24 at 8:00 am.

9/12/2014

First log; accomplished so far:

  • Met with group twice, first time for Milestone 1 and second time as first regular group meeting
  • Contacted customer, Drew, who will be back in town next Monday.
  • Submitted form for group letting Dr. Vidal know when we can meet
  • Downloaded Erlang to personal laptop. Also visited some links and posted them on the wiki regarding Erlang tutorials.
  • Began familiarizing myself with Erlang