The final sprint review of the semester was very successful with our component finally being completed. We ironed out some bugs before finally completing our form component. We worked on the dialogue box that needed to popup after the submit button was clicked. We imported a new module and created a new component for this solution. The module was called MatDialogBox and it was imported from the angular library, but we needed to create a new component to implement it correctly according to the documentation. We had multiple issues with formatting the popup box with buttons that said done and cancel because the default dialog box comes with a text field instead. Once finished, we pushed the changes and asked our instructor to finalize the merge. We realized that there were issues with multiple similar imports from various projects which lead to complications as I had mentioned in my previous sprint reviews. This stage was the stage that I worried about the most throughout the project and reflected on. The merging of our code with other teams’ components turned out to be much more complicated than I initially thought. We needed to remove any imports for angular modules that were repeated within every component that was made in the final project. We had to sift through various groups code to make sure there were the correct imports while also making sure it would compile correctly. We ran into issues very quickly when we ran the program since it wasn’t properly styled. The components that we made overlapped each other when we served it. This meant that the visual details in the html and css files needed to be further modified. We looked into moving the tab component around and the homepage to make sure our component was underneath which proved fruitful. However, formatting the entire project to be visually appealing turned into a nightmare. The branches that we initially pulled to piece the components together turned out to be a branch that held broken code. There was a different branch that held the compatible code with other components which led to confusion in the beginning when we tried to serv the project. We were suggested to leave this task to the integration team, but we still wanted to persevere and try to find some way to make things easier for them. Finally finishing the Q-Form component was a very interesting experience as was this entire project. We went from using real Ampath code to making our simple app that would run off pre-determined data that we would feed ourselves. It was a great learning experience as to how to communicate with a team and understanding a groups workflow to enhance communication between each other. This allowed us to debug together and solve issues much faster in person compared to over our communication channels. I realized that we really crunched through any questions or troubleshooting very efficiently when in person compared to online. This sprint really taught me to understand other people’s point of view when debugging. I learned to be patient and try to understand another mindset even if it takes me longer than necessary. The final presentation really showed me how patience and teamwork can prove to be useful in the grand scheme of things.
Our fifth sprint really allowed us to sink our teeth into the project and build our first component. We continued to have bugs and issues with git and node modules that we had debugged earlier in our third and fourth sprint. These bugs have come and gone randomly among our team members which made working in synchronization much harder because not everyone had a stable version running at all times. We debugged the issue through various methods using multiple pulls from other branches in git to solve the issue. The first error started with the CSS formatting that had been troubling us for a long time. We had originally solved the issue, but it came back once again when we pulled a fresh copy of the project from our branch repository. We decided to pull another version of the project from another groups branch and debug their files to see if the problem was with our local machines. It seems that the issue was with our file structure for our git branch because the other groups branch was running just fine. We decided to look further into the file structure of our project and reorganize the node modules to see if we could solve the issue. After further reinstallation of the node modules through the npm install command, we were able to get an interface up again. The CSS now works fine with the HTML and other application files. The integration of the Q-Form component with the app files within the code is our next real goal. We want to easily connect the component to the app files so that we can finally see if the function is up to our visual standards. We also have to decide if we want to select subgroups to finish this component while another set of people begin working on the next component. We will have to discuss this as a group during our next sprint, but I believe we are on the right track for this development cycle. We have solved many issues and are almost done making our first component. There has been talk about communication with an integration team that will be handling the total integration of various components into a demo file for the application. It could be possible that we have to mock some information as well for data instead of a server. It would be easier for time constraints to make random data rather than set up a server so that is definitely an option. The option of multiple people debugging a problem is comforting and it allows a fresh look onto an engaging topic as well. I personally enjoy group debugging because it makes the learning experience much more enjoyable. This sprint really taught me to understand other people’s point of view when debugging. I learned to be patient and try to understand another mindset even if it takes me longer than necessary. This proved to be vital when communicating with team members and allows a feeling of inclusion as well as mutual understanding.
Our fourth sprint laid the first real groundwork for the project design and coding. The AMPATH developers have given us more information as to how they want the simple app to look like. It should have a simplistic design within the flow and written code of the app to make sure it works properly. We created a new repository from a more updated version of the original files given to us. The original files were lacking in certain angular development modules so importing certain components and data became an issue quite quickly. The updated files now have those development modules which we have just cloned onto our computers and created a QForm component for the questionnaire form. We had to delete our previous branch known as questionnaire-form because it wasn’t up to date with the new files. We decided it would be easier to create a new branch from the new files and start over in this manner. We created the new QForm component and have laid the groundwork skeleton for how the design should look within our CSS and HTML files. The CSS is giving us issues however, because the form that we imported was vertical in format while the one that shows up when we ng serve is horizontal and slightly unformatted. We will continue to work on these issues to make sure they are ironed out and looking as proper as possible. We debug any issues we come across separately on our own and then bring it to the team if we can’t seem to figure it out. The option of multiple people debugging a problem is comforting and it allows a fresh look onto an engaging topic. I personally enjoy group debugging because it makes the learning experience much more enjoyable. I still think that the hardest part for the future will be to connect each component together and bind them into one final app with the other groups. We’ve already started collaborating with other teams on what information we all will be needing from a mock server. It will be necessary for the future so I think we should discuss how this server will be setup and which development tools will be used. We should also understand how data types will be formatted within this database so as to hold only meaningful information. It would be interesting to see how patient data types are handled at AMPATH but we’ll just have to make our own version based on guessing. I’m now more worried about connecting the CSS and HTML for the final application to make sure everything looks nice and simplistic since we had issues with our own CSS. We want to continue to understand how we should edit and evolve the code already given to us and turn it into the final product that they want. The most important aspect of this design that we decided on seems to be simplicity with functionality. We want to incorporate that using the imported modules while also gaining knowledge on how they designed their app.
The “Sweep The Floor” pattern is described as a way be able find your place on a new team that is unsure of you. This pattern expresses how to find a way to earn your teams trust and contribute to their work without getting in their way. A good way to start is to volunteer to do simple tasks to show initiative and competence for small tasks to eventually work your way up to the big ones. An important fact to remember is to go for quality of work rather than quantity to ensure your teammates of how seriously you are taking this opportunity given by them. This may seem like a step back from all the studying and preparation you’ve done to get to the point, but you must also remember that now you are hired to be on this team. You must prove yourself before they can put any sort of trust in you and the best way to do that without causing any accidents are smaller tasks. This does not mean that you should let the team see you as the pack mule for meaningless tasks, but rather someone who can pick up the slack if needed.
I found this pattern to be a great introduction to read before really starting out on a team. It allows an easier incorporation to the team dynamic and earn a teammates trust. It created a good sense of what to do and not to do so as to make sure that you are doing extra work for the good of the team while not becoming a pack mule. I want to start using these skills and think that they will definitely make working in a team easier. I think it will make the workload harder, but it seems to be a good trade off to earn the respect for other teammates. I agree with this pattern for that very reason because respect is a very big deal in teamwork. Every team member should prove their skills and respect for the good of the team. I want to continue this practice to make sure that my dedication and commitment to the team is seen to create a better bond with teammates.
Our third sprint enlightened the path the group planned to take with the other groups for the splitting of objectives. The AMPATH administrators were able to give us more information based on the project specs that included wireframes of each component that we needed to create. The team heavily benefited from the clearer explanation by being able to divide the work out to our team members in a productive manner. We were able to understand what the project generally asked for and began working on our first component for the angular project. This sprint also gave us more time to look at the code AMPATH had given us for reference material on variable naming and options when creating the components. We compiled ideas on our first component and finalized that we would work on the form component. We analyzed the videos that were related to that component and realized that it could be made fairly easily but there were more questions that needed to be answered. We found that the question fields for the form were not stated, so we decided to create their names based on their question number. We would like to implement real questions, but we can only do that once we confirm this is needed with AMPATH. I think that we should proceed to understand the AMPATH format for their angular code and look into understanding how we will possibly setup the Mockito style of testing we are aiming for. A better understanding of the project will be needed to further enhance the user experience so as to create a flow within the program that seems seamless to the backend user. We want to continue to understand how we should edit and evolve the code already given to us and turn it into the final product that they want. I think that the hardest part for the future will be to connect each component together and bind them into one final app with the other groups. This is going to take a good amount of proper communication to achieve. It will be necessary for the future so I think it would be a good idea to start talking to the other groups about this now. This will keep them on alert and conscious of the code they write to make sure it can be understood properly by someone on another team. This app will be used by back end users for simplistic tasks such as filling out questionnaires and taking notes on patients based on their medications. It seems that another team has also found some Mockito code within the files given to us by AMPATH that could be useful in creating our own data to be fed into the application. I’m uneasy about the lack of information we have based on variables in play when looking at patients between our version of the application and the AMPATH application. I hope that the transition of data between the two applications would go smoothly but it doesn’t seem reasonable to think that this process would go without hiccups.
The “Rubbing Elbows” pattern is described as a way be able to branch out and meet other developers instead of working alone. The book talks about how productivity and learning can understandable plateau if you constantly work alone. The best learning experiences come from balancing private learning with team learning whether that be in a large team or simply coding with another person. It allows you to learn things that can only be understood when you and another person have a shared goal in mind. There are little quirks that you can pick up when working with someone that a mentor may leave out or find trivial to teach due to the small scope of learning it provides but over time these quirks can add up. This being said, there are also negative effects of this pattern to watch out for. An example would be to not pick up bad habits that your partner may develop or have. Another example is to make sure to not fall behind on your part of the work because it then hinders your partners learning progress as well if he has to pick up the pieces behind you.
I found this pattern to be understanding of solo programmers and shows them a way to learn more through working in teams. It showed that working in groups and teams can build communication skills and increases exposure to several coding styles. I found that when the book mentioned pair programming as an example, I got much more interested in the topic. The idea of switching off coding seems very interesting to me and makes me want to learn more for an experience programmer. I want to incorporate this mindset in my work environment to learn better from my peers. The pattern did a good job on the negatives as well by going into subconsciously learning habits that aren’t good for you. This can be helpful to keep me mindful that some habits should be avoided or corrected to increase proficiency at the language. I agree with this pattern very much as it has taught me to value pair programming much more and has instilled a new interest to find a coding buddy to learn off of.
The “Practice, Practice, Practice” pattern is explained as one of the better ways to develop your skills in new areas and get better with hands-on learning. The book continues by saying that being able to learn skills on your own time gives you multiple benefits that can’t exactly be emulated in a work environment. In a work environment, you constantly feel the pressure of learning new skills and learning them quickly while practicing by yourself allows you to control the rate at which you want to comfortably learn. The main idea of this pattern is to have a stress-free environment for you to experiment and eventually learn in. The idea of integrating feedback loops should also be in the back of your mind since it could prove useful here. It is possible to develop bad habits as you practice so making sure that someone can give feedback on your practice afterwards is also crucial. This allows a better learning experience in the long run by quickly correcting any habits that form rather than letting them sit with you for an extended period of time.
I found this pattern to be important and useful as a reminder to make sure that I keep practicing. It outlined the positives of practicing code and how to set a personal pace for learning compared to a work environment. I found that when the book talked about the fast pace of work being different from learning at home, it resonated with me much more. I want to incorporate this pacing technique for personal learning more to find out how it can affect my overview on a subject. I predict that it will allow me to continue learning without getting too burned out since I would be able to control the pace at which I want to digest information. This can be helpful because there are some days where I don’t feel like working a lot which allows me to control the learning load compared to days where I want to learn a lot. I agree with this pattern for that very reason, to be able to personally create my own time schedule as long as I continue practicing at a continuous rate. Practice can only make my knowledge base greater and it allows me to experiment with ideas that I wouldn’t be able to in a work environment at my own pace.
The “Read Constantly” pattern is described as a way to create a strong base of knowledge and an even better understanding of the industry around you. There seems to be such a vast amount of information out there today that it seems very intimidating to even fathom where you should start. Reading is the best way to start learning more about the industry and more abstract yet fundamental concepts. The idea of reading everyday may seem like a lot of work at first but the key is to completely immerse yourself into the context of the text. Find new ways to apply what you learn to what you are working on and familiarize yourself with patterns before they become more popular and widespread. Another good way to read is to section parts of the book into manageable pieces to organize your learning experience such that it flows easier reading from one chapter to another. The book also talks about momentum when finishing books by allowing a brief but not long period of absence from reading. Find your next book and move onto it as fast as you can without creating a disturbance in your work life.
This pattern was interesting because it showed me a way to read without making it too overwhelming. Every book I find on coding seems to become very overwhelming with the amount of content inside. The content itself becomes boring when reading for too long, it begins to sound repetitive which leads to a lack of interest. I found the tactic of breaking these large amounts of reading into smaller portions a great idea. I’ve been currently applying this tactic with great results as I can retain the smaller amounts of information better and this allows me to keep a more vested interest in the book. I also found that focusing on the portions of the book that interest you can make it easier to read. Focusing on ideas and aspects that you want to learn more than the rest makes the reading go by much faster. I agree with this pattern because of the amount of information that is available at all times to us. It’s very important to use our resources to the best benefit we can take from them. Books and online readings are everywhere these days and it makes information much easier to obtain, so to sharpen your skills you must broaden your skill set as well.
Our second sprint had little coding action and more of a personal learning aspect that we decided to focus on. I found that the team benefited from individual learning in a similar fashion to an independent study when trying to learn about important concepts like Mockito testing and Angular formats. We then compiled our individual learning resources into our slack channel to help each other find resources that others may have missed. This allowed an easier flow of understanding while also being able to bring us all onto the same mindset of where we were in terms of starting the project. I will proceed to understand the AMPATH format for their angular code and translate that knowledge to the requirement we will need to meet in the future. AMPATH members have recently posted videos and presentations of how they want their new interface to look with explanations for user interactivity. We want to continue to understand how we should edit and evolve the code already given to us and turn it into the final product that they want. We will have to communicate not only with our team member but the other teams as well to go over which functions should be divided up and worked on. This will create a better organization system for how we should communicate with other teams as well to understand any implementations that they will do which might affect our portion of the project. We learned about how the AMPATH project works through the videos which explained everything from selection tabs to navigation elements. It seems that this design concept may be similar to that of a mobile app from the setup of the mockup files which makes our approach much easier to narrow down. The most important aspect of this design seems to be simplicity with functionality for the patients and their doctors. The ability to create a smooth design is going to be complicated with different teams working on separate functions that are supposed to come together to create this app. It will require concise and mutual communications from several fronts that we will need to perfect over time. I predict that in the beginning it will be difficult to explain our coding schemas and ideas properly to each other but once everyone gets a taste of each other’s coding styles, it can be done with minor hiccups. We also need to decide whether we will stick with the idea of using a Mockito style for our testing or setup a server on campus to continue working with fake data. We have communicated with multiple teams about this idea and think that we should at least try to see if setting up a server is viable with as few hiccups as possible otherwise, we will have to look further into testing. I believe that setting up the server could work out well for every group, but it could cause issues with connecting and internal errors that we wouldn’t be able to figure out properly. It is definitely worth a try as it would be an interesting experience to understand and make it easier to test if we should be able to get fake data.
The “Find Mentors” pattern is explained as the search for when beginners start looking for developed craftsman to show them a specified path. The book explains that the first step is to find someone who is already ahead of you and try to learn as much as you can from them. Eventually, someone will take on an apprentice and you will be able to establish a better idea of your future from there. It can be difficult to get attention from a single master as they try to teach you and try to work on their own projects. This can lead to having multiple people looking over your growth to make sure that there are multiple inputs to your learning experience. The important part of this step is to make sure to not get frustrated or confused with the multiple sources of information. Masters also have their own weaknesses, so make sure that you understand exactly what those weaknesses are and how you would change your learning methods to accommodate those weaknesses such that they aren’t mirrored onto you.
I found the Find Mentors pattern interesting because it explains the benefits of having someone who can guide you while also explaining how to further enhance your learning with multiple masters. It taught me to understand the issues of having a working mentor when it comes to workloads. I had never thought about how the masters have their own lives to juggle while also trying to teach their students. I found that the idea of getting multiple master was useful but that it could also come with its own drawbacks in some scenarios. It would be tough to find a reliable master and the more masters you have, the more likely it is that one of them may be leading you astray. This idea is what I don’t like about this pattern and I intend to apply it to my own learning. I don’t mind finding a master as long as I feel comfortable double checking them to make sure that everything, I’m learning is correct and won’t harm my growth. Other than those drawbacks, I understood and enjoyed this pattern. It’s repetitive nature of the learning process for students is easy to grasp which makes that much easier to apply.