Project 3 phase 2 implementation details

For the next phase, Ellen will implement GameInput and Matt will implement GameScore as documented in the class diagram.  Ola will oversee the implementation and make sure the implementation is completed in a timely fashion.  In addition, Ola will make sure the InputDebouncer and GameInput classes interact as described in the design diagram.

Please consider the following during implementation:
   
1. Does the design diagram give sufficient information to complete the implementation?
If not, what needs to change in order for that to happen?
Please submit any questions regarding design to the Slack channel or here.
   
2. What role does my implementation serve in the overall game design?
Since we are focused on input, our implementation is critical to the testing of the application. Because we are so critical to the success of the project we will have a condensed timeline for implementation.
   
 3.  Am I using all available resources to complete my implementation?
 If, at any time, you become stuck or don't believe what you are doing is correct, ask questions.
Also, the prototype provides most of the information necessary to develop your solution.

We will be following this timeline from here until completion.

The initial implementation should be completed no later than 29 October 2016 at 3 p.m. CST.
 Matt, please review your implementation and make any necessary changes by this time.
 Ellen, I will begin your implementation so you have something to reference.

I will code review at 3:15 p.m. CST on the aforementioned date.  I will message/post all changes, if any, that need to be made.
All subsequent changes are due by 7 p.m. CST on 29 October 2016.

Please note:
The changes we make will be based on our design not the overall implementation.  There's no telling what additions/subtractions will need to be made until integration testing takes place.

If this timeline doesn't work for you, please say something immediately.  If these times don't work, please say something immediately.  I will pick up as much slack as I can.

Project 3 - Tetris Initiation

Initially, we looked at the project as a whole and began by breaking down each part into components to start working through as individuals. These became the input, the input bouncer, and something to keep track of points as the game was being scored. For me, it was slightly overwhelming seeing the light at the end of the tunnel, but as we started breaking down each component things starting fitting into place.

When we started looking at each component, we first started playing the game to see the general layout and how the game was played (differences from other tetris games etc). For the input, we had to document each interaction that a user would have with the game and how the game reconciled these inputs. This included keystrokes, mouse, and sound. At later stages it also included how these things affected one another in the sense of how the game was played.

At later stages of our discussion, we were able to get some classes identified for each list of interaction and set a layout for our design with a series of established interconnected classes. A big part of this challenge was compiling and syncing everyone's ideas into a general format, but it came together and with some small commissions and additions a final design was established and ready to be implemented.

Project 2 - Implementation Phase

Immediately following the distribution of team projects and receiving our "Spin Design" implementation and having Matthew set up our project, Ola jumped on building the architecture for our methods. The design that we received was very detailed, but with a lot of loops and hard work an excellent draft came about. Working through the solution and a lot of back and forth discussion behind the scenes, we put together a main to test the methods established and had Bryce upload fixes. We corrected the bugs and errors and tried to work with the other group to correct any misunderstandings. Upon completion, we also saw that other designs had been uploaded and we were allowed access to view the implementation of our design as well as others. A note made after reviewing the other team's implementation was that interfaces were not a useful implementation to our bucket design, so we have set to notify them of our feedback. I look forward to going through other team's code and seeing their solutions. While some teams had unit tests that weren't a requirement for the design, we put together our tests in the main. After further analysis, we denoted that the main program would be sufficient.
-Ellen E

Perforce Project File Upload

Tonight, I have uploaded the Perforce shared project file to our team folder,  and created the three empty classes that we will be filling in. We still need to figure out the best way to split up the work load among us, but I figure it's better to start everyone off with the classes started rather than empty.

Project 2 Implementation Phase

Last night, at the end of lecture we met with our group that we are implementing the design of. We are going to be complementing the "Spin" customer specification. We are going to be going through Bryce, from our group, and Brian, of group 4, as our means of communication. We are all going to read through their documentation individually, and will set a time of when to decide how we are going to delegate the work out to each of us. This should happen within the next day or so, and I will be posting further details at that time.

Project 2 Evaluation

While a lot goes on behind the scenes, our project 2 is coming together. During our meeting this weekend, we discussed different implementation strategies and overall architectural designs for our project. Based on the document requirements for our project, we discussed efficiency and running time for our implementation ideas. After a lot of fine print reading, we established a preliminary design based on a type of doubly linked-list that could be a container for lists of items. In the next couple of days we regrouped and discussed through our portal any changes and different tweaks that we could make to the design implementation to make it even better. At this stage, after many revisions our group has established a comprehensive design to implement our strategy and the general consensus is that this is a strong design.
-Ellen E.

Project 2 Design Documentation

After discussing amongst our group, Bryce had offered to create some UML class diagrams to further illustrate our implementation plan. Using these diagrams as a visual, we began the collaborative process of creating the document that is to be used by the group meant to implement our design. Over the past few days we have refined the document and will be posting this to our team's project 2 blog, that the next group can use as a guide.

SE 475 - Project 2 (Design) - Buckets

For project 2, I, Matthew Smeraglia, will be the group leader. We are tasked to design the Buckets customer specifications. To plan this project, among our group we agreed to review the project and come up with an implementation plan individually. Today, we are going to discuss and review each others' plan and come to a common agreement and create a plan to move forward with the most efficient implementation. We will also be delegating specific portions of the design docs among each other.

My Final Evaluation of Project 1

Well, I have to admit, this project was a bit more time consuming than I originally thought it would be.  It seemed as though I was running out of time every time I started developing a new test.  I know for a fact that testing takes a long time, but for some reason this was overkill.  I'm not sure if it was the language (C#) and understanding the nuances around it, or if it was the type of program we were testing.  Ultimately, I'm not sure it matters all that much.  What does matter, is that our team finished the project on time with the amount of detail necessary to effectively test an application.  The experience we gained from this exercise will certainly help us going forward.

Project 1 Report

Our project is coming along! Everyone is nearly finished with their methods. The full written report is located here.