Category Archives: CS@Worcester

Sprint 3 Retrospective

Introduction

  • In this sprint, our primary focus was on rigorously testing the frontend developed during sprint 2, applying the insights and frameworks we had discussed with team 2. This sprint appeared significantly shorter than the extensive sprint 2, partly due to the lighter workload with a target of only 16 points. This more manageable workload allowed us some capacity to address and rectify lingering issues from the previous sprint.
  • The brevity of this sprint highlighted the importance of continuous integration and testing, which enabled us to quickly identify and resolve issues. Our collaborative efforts with team 2 proved invaluable, as their feedback directly influenced our troubleshooting and refining processes. Moving forward, maintaining this synergy and applying these practices consistently will be crucial for smoothing out any future bumps in our development process and enhancing the overall quality of our project.

Links to Activity on GitLab

Reflections on the Sprint

What Worked Well:

Advertisements

https://c0.pubmine.com/sf/0.0.7/html/safeframe.html

REPORT THIS AD

The standout success of this sprint was our group communication. Facing challenges as a team, rather than individually, significantly eased our problem-solving process. Our review procedures were effective, facilitating a focused approach towards achieving our objectives.

Areas for Improvement:

The primary challenge we encountered was time management, particularly as progress on the front end depended on having a working template. This dependency delayed our efforts, resulting in a hectic sprint conclusion. Better planning or earlier template availability might mitigate similar issues in future sprints.

Improvements for Team Performance

The team’s collaborative communication and problem-solving were key strengths this sprint, continuing a positive trend from the previous sprint. It’s crucial to sustain this momentum into the next sprint, incorporating some strategic improvements:

Improvements for the Next Sprint:

  1. Consistent Scheduling: To avoid the congestion experienced towards the end of the last sprint, establishing a more consistent schedule for meetings could help in better time management and distribute tasks more evenly throughout the sprint.
  2. Balanced Division of Labor: We should continue to monitor and adjust the workload among team members to ensure tasks are evenly distributed, preventing any team member from being overwhelmed while others have less to do.
  3. Streamlined Communication Channels: Building on our previous success, maintaining all critical communications in a centralized, organized, and easily accessible system will enhance clarity and continuity, aiding in more effective decision-making and problem-solving.

Personal Improvements

Reflecting on my personal challenges during this sprint, specifically around managing merge requests correctly

  1. Proactive Communication: To prevent and swiftly address any uncertainties or errors in my work, I commit to being more proactive in seeking feedback and clarifications from team members.
  2. Frequent Check-Ins: In realizing the significance of team alignment, I commit to checking in more frequently with my team members. By maintaining regular communication and seeking feedback, I aim to ensure that our efforts remain aligned towards our common objectives throughout each sprint.

From the blog CS@Worcester – CS: Start to Finish by mrjfatal and used with permission of the author. All other rights reserved by the author.

448 – Blog Post

“Rubbing Elbows” advocates for the power of hands-on collaboration with another software developer to overcome learning more and enhance craftsmanship. This pattern complements “Kindred Spirits” by emphasizing the benefits of direct, side-by-side interaction in skill development.

Dave’s experience with Roman shows the efficacy of this pattern. By working closely together, they not only learned about new technologies but also gained insights into micro-techniques that are often overlooked in traditional teaching settings. The narrative shows the significance of collaboration, even outside formal mentorship relationships, in fostering skill enhancement and professional growth.

Pair Programming emerges as a concrete ideaology of “Rubbing Elbows,” offering apprentices invaluable opportunities to learn from more experienced developers. While pair programming can be challenging, especially for apprentices, it provides a dynamic environment for skill acquisition. The pattern advises apprentices to communicate effectively with their pair programming partners, seek rotations if necessary, and explore alternative methods like Ping-Pong Programming to enhance participation.

Drawing from Richard Sennett’s concept of the ideal craft workshop, “Rubbing Elbows” advocates for exposure to diverse working habits and practices. This extends beyond coding to encompass all aspects of software development, such as academic collaborations or open-source projects. Ade’s experience illustrates how collaborating on unconventional projects can broaden perspectives and lead to unexpected insights.

Regardless of the outcome, apprentices are encouraged to record their experiences and reflections for future reference. This documentation serves as a valuable resource for personal growth and facilitates empathy towards future junior collaborators.

In action, the pattern suggests initiating collaborative projects, such as contributing to an open-source project, with someone interested in similar pursuits. By committing to regular sessions and adapting to challenges, apprentices can sustain motivation and continue their learning journey.

In summary, “Rubbing Elbows” underscores the importance of hands-on collaboration in overcoming learning plateaus, fostering skill development, and enhancing craftsmanship. Through direct interaction and shared experiences, apprentices can accelerate their growth and achieve mastery in software development.

From the blog CS@Worcester – CS- Raquel Penha by raqpenha and used with permission of the author. All other rights reserved by the author.

448 Blog Post

The piece “Draw Your Own Map” encourages individuals to take control of their career paths rather than relying solely on their employers or societal expectations. It addresses the common notion that programming and career advancement in the field are limited, especially for those who may not fit the stereotype of fresh graduates. It emphasizes the importance of identifying one’s own career goals and taking proactive steps to achieve them.

The solution proposed involves identifying logical yet ambitious career steps and visualizing the incremental actions needed to reach those goals. It advocates for taking the first step, even if seemingly insignificant, as it generates momentum towards larger aspirations. Rather than setting only high-level goals, the article suggests defining small, achievable steps that provide feedback and aid in obtaining assistance from like-minded individuals.

The narrative includes personal stories illustrating individuals’ struggles to pursue programming despite organizational constraints. It highlights the importance of prioritizing personal aspirations over organizational expectations and seeking opportunities that align with one’s goals.

The actionable advice includes listing potential career paths, extending the list to explore additional options, and challenging preconceived constraints to open up new possibilities. It also encourages seeking mentors and kindred spirits who can provide guidance and support along the way.

Overall, the piece advocates for a proactive and flexible approach to career planning, empowering individuals to chart their own paths and overcome obstacles to achieve their desired destinations. What I thought was the most important of this piece is the career planning aspect of it especially since this semester I am finishing up my degree and starting on looking for a career, this also like points me in the write direction on a professional work future.

From the blog CS@Worcester – CS- Raquel Penha by raqpenha and used with permission of the author. All other rights reserved by the author.

CS-448 Sprint 3 Retrospective

Files · jlee1999/check-documentation-and-39 · LibreFoodPantry / Client Solutions / Theas Pantry / ReportingSystem / GenerateWCFBReportFrontend · GitLab

Since the last sprint my team was assigned to verify the pipeline tests and linters for this branch, I worked on looking over and adjusting the documentation in the repository to match any changes made. When I tried to run the frontend, however, it was not loading properly. After looking at the documentation, I worked on fixing the front-end functionality or at least making progress in it to set up the students next semester that will be working on it.

feat: merge branch ‘jlee1999/fix-documentation-in-guestinfobackend-126’ into ‘main’ (32d05a94) · Commits · LibreFoodPantry / Client Solutions / Theas Pantry / GuestInfoSystem / GuestInfoBackend · GitLab

Like GenerateWCFBReportFrontend, my team worked with GuestInfoBackend last sprint to implement nodemon into the repository so that developers can hot reload the servers whenever they adjust the code in the source folder. After making those changes, I worked on matching the documentation with the previous changes to make it easier for other people working in the repository to know how to run the backend in production mode versus development mode.

Files · implementing-nodemon · LibreFoodPantry / Client Solutions / Theas Pantry / InventorySystem / CheckInventoryFrontend · GitLab

Over the course of the semester, my team has been working in the CheckInventoryFrontend repository to work on different issues. One thing we were struggling with was getting the front end to load properly to see the layout. In this branch, I was able to fix the front end to load properly so that we as developers can see what the layout will look like to the client. I also worked on implementing nodemon in this repository to hot reload the backend servers to put it in development mode.

Files · jlee1999/fix-documentation-in-the-39 · LibreFoodPantry / Client Solutions / Theas Pantry / InventorySystem / CheckInventoryFrontend · GitLab

This issue dealt with fixing the documentation in the CheckInventoryFrontend repository to match all the changes my team has made throughout the semester. We worked on setting up the repository to look like GuestInfoFrontend which made the repository more organized and easier to navigate. With all those changes, however, the documentation that was previously there was now outdated. While it might not be as glamorous as other work, adjusting the documentation is important and will help future developers when they start working on this project.

This was the last sprint for the semester, and I believe that it went as well as the last sprint. Each team member was tasked to do specific issues that did not necessarily need work from multiple team members at once, which helped spread the issues throughout each of us. The one issue that required multiple team members at once was the overall updating of CheckInventoryFrontend but we were able to split up that big general issue into smaller problems that each member can focus on in their own time. I continue to feel confident in the gitlab setting and have had an easier time navigating through each repository and have improved in that aspect compared to the beginning of the semester.

I will say what changed from last sprint to this sprint was the decrease in communication throughout the team, but I do not think it hindered our progress as much as it would have previously. Since the issues could be worked on individually, we would still update each other through the stand-up meetings and were able to get enough progress through the sprint to reach our goal. There was sometimes confusion amongst us on what part of CheckInventoryFrontend to work on.

As previously mentioned, I think communication amongst the team could have improved which would have only increased our team’s production throughout the sprint. I am not sure why it dropped this sprint, but there were times where I would try to message the team to get something approved or ask for progress through their issue, the communication would be delayed. It did not completely hinder us since we still fixed enough issues to reach the weight requirement as a team. I started to get the hang of focusing more time and energy on one issue rather than multiple at once but also knew when it was time to stop before hitting a wall.

From the blog CS@Worcester – Jason Lee Computer Science Blog by jlee3811 and used with permission of the author. All other rights reserved by the author.

Sprint 3 Retrospective

After finishing our last sprint I believe it went very well compared to our last two sprints. Our team did a great job of communicating, time management, and ensuring everyone’s ideas were heard. We also made sure that issues were assigned equally and that our issues weren’t sitting in needs review. I believe we didn’t have any issues for this sprint since the last two gave us a better idea of what we needed to do this time. As a group of 5, we needed a weight total of 25, we managed to complete over 75% of our issues. Since the last sprint, I believe we made a lot of progress as a team and managed to get through this sprint without any issues.

As a team, I believe we made a lot of progress in this sprint and didn’t have any issues to work on. We made sure to communicate with each other about how everyone’s progress was going on with their issue and if they needed any help with anything. The reason why we managed to get through this sprint is because of our communication and teamwork. Like I said earlier I believe that as a team for this sprint, we didn’t have anything that we needed to improve on. Our working agreement helped us get through these sprints by making sure we were straightforward with everyone and that we got to improve each time. Based on the last two sprints, we’ve grown improvement-wise. We made sure to stay on top of any work that needed to be reviewed, communicated with each other, assigned issues equally, and managed our time very well. I enjoyed working with my team members and was glad that we were able to complete this sprint without any issues.

As an Individual I believe I made a lot of improvements since the last sprint. I made sure that the work was even spread out between me and the team, I also made sure that we stayed on top of reviewing each other’s work. The issues I worked on were Update and Review Documentation GuestInfoSystem and a couple of group issues like Determining what needs to be done in GuestInfoFrontend. I made sure that the guestinfo system documentation had the right extensions, linters and that the pipelines were working. Then as a group, we worked on the GuestInfoFrontend and created a couple of issues that next year’s students can work on for their sprint. Some issues we created were moving “Other Assitance” attribute and moving receiving unemployment attribute to assistance. Those issues will help the GuestInfoFrontend look cleaner and see what is missing in the code that for some strange reason gave us a harder time to deal with. With this being our last sprint I can proudly say that our group did a great job in getting the work done and communicating with each other. By learning from our mistakes we were able to get through this sprint without any troubles and managed to get it done quickly.

From the blog CS@Worcester – Kaylene Noel's Blog by Kaylene Noel and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective Blog #3

Hi everyone, my name is Abdullah Farouk, for those who don’t know me by now, and this is going to be my first sprint retrospective of the semester. First, I will start out by saying, considering this whole thing is brand new to us, we did a great job working with this new style and adapted quickly to all the changes. Don’t get me wrong, there is still a lot of room for improvement from everyone in the team, but we successfully passed through this semester. This sprint consisted of us getting more familiar with libre food pantry more and to see how this scrum framework actually go and went more in depth into the actual system. The first thing we did in the beginning of the semester was weighing the different issues and breaking some epics into smaller issues and assigning it to our team. We then organized the issues on which one we wanted to do first and so on. I worked on most of the issues during class time, which worked out nicely because I had my team member there to help me with things just in case, I got stuck, which I did sometimes. I liked meeting in person instead of virtual meetings, as I think we do more work when we see each other instead of behind a computer screen.

One thing that I would say the we massively on was how we weighed the issues in the beginning. Compared to the first sprint, Some of the issues took less than what we had anticipated, and some took way longer, but this sprint we got it spot on and managed to finish all the issues on the board just in time. Another thing that we improved on was communicating outside of class time. I started privately messaging class mates for updates if they haven’t said anything in days. One thing we still didn’t do well was Some of the issues we had made, we didn’t add a description to it, so it was a little harder for me to figure out what they want me to do just from the title, so I had to ask classmate to double check.

Other than that one issues, I think me, and the team did a great job going through these issues and completing them on a timely basis. I worked on multiple issues for this sprint that I will list at the ends, but mostly I was trying to clean up code and made sure anything that I had left unfinished, was either finished or deleted so the next class is not having a headache trying to figure out why it’s there. I also checked a couple of my classmate’s issues that needed to be reviewed in order to merge to main. I also worked on. I also learned a lot about nodemon function and have a basic understanding of how it works and how to properly integrate it.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkinventoryfrontend/-/issues/29

  • Update CheckInventoryFrontend

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/reportingapi/-/issues/25

  • Verifying that ReportingAPI has correct extensions and linters

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkinventoryfrontend/-/issues/27

  • Think and write down possible ways to further enhance the CheckInventoryFrontend

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkinventoryfrontend/-/issues/26

  • Examine GuestInfoFrontend with its wireframe to see if there is any helpful code that can be shared

From the blog CS@Worcester – Farouk's blog by afarouk1 and used with permission of the author. All other rights reserved by the author.

Summary of Testing

Hello everyone,

This is the last blog of this semester, so I want to share the knowledge and experience I have learned this semester, as well as my expectations and opinions on testing work.

I have learned a lot from having little knowledge of this test at the beginning to now having a basic introduction. Start by understanding the meaning of testing. Testing is not a job that only requires reverse disassembly of the code to ensure that it runs. It is very complex and requires you to use tight logical thinking to challenge the code from all aspects. For example, it is not only based on the input designed by the code, but also based on all forms of input to test whether the code will run or crash. And I also learned about equivalence class testing, such as what Normal/Robust and Weak/Strong testing are. These are very interesting and they have opened a door for me into the field of testing.

They also got me interested in testing jobs, and I’m now starting to pay attention to jobs related to game testing and code testing. I still have a positive view on the future of this type of work. Testing teams are very important to both businesses and customers. He ensured unnecessary losses and savings.

Moreover, in the assignments and activities this semester, I also learned how to use effective testing tools to help us conduct testing work more efficiently. With the help of tools, we can save a lot of working time and let AI and tools do low-efficiency work, while we can concentrate on high-efficiency work.

Anyway, the knowledge I learned this semester will be of great help to my future and work. I hope everyone who reads this blog can try to understand and learn software testing. I hope it will be helpful to you.

From the blog CS@Worcester – Ty-Blog by Tianyuan Wang and used with permission of the author. All other rights reserved by the author.

A New Belt, A New Perspective

This week I chose to read “The White Belt” section under “Emptying the Cup”. This pattern calls for one to fully embrace the beginner mindset when faced with new learning opportunities. It encourages placing preconceived ways of thinking aside when tackling new situations to do so with a clean slate to allow for new perspectives to be formed. By subscribing to this mindset, one can increase their learning and understanding of different languages which in turn will aid them to progress their path as a craftsman forward.

This pattern highlights the importance of learning in professional growth because, in today’s rapidly evolving market, the ability to adapt and learn new skills is crucial for staying relevant and competitive prospects. Reaching a certain level of expertise may cause one to fall into complacency or build a reluctance to venture into unfamiliar territory.

What I find insightful about this pattern is its analogy to martial arts, where the white belt symbolizes a beginner’s journey toward mastery. Just as a martial artist must approach each new technique with a fresh perspective, a software craftsman must be willing to let go of their preconceptions and embrace the unknown. This pattern serves to remind readers that mastery is not a destination but a continuous journey of growth and self-improvement.

The pattern also highlights the discomfort that can accompany stepping outside of one’s comfort zone, especially for experienced craftsmen. As someone who takes pride in their expertise, it can be challenging to admit ignorance or make mistakes. However, the quote from George Leonard reminds us that embracing foolishness and spontaneity is often the key to unlocking creativity and innovation.

I appreciate the advice provided in the pattern, such as unlearning something familiar or exploring new programming paradigms. This encourages craftsmen to actively seek out opportunities for growth and challenge themselves to expand their horizons.

While I agree with the overall premise of “The White Belt,” I recognize that fully embracing a beginner’s mindset requires courage. It’s not easy to admit when we don’t know something or to let go of our old ways of thinking. However, as the pattern suggests, the benefits of adopting this mindset far outweigh the temporary discomfort one may feel.

In conclusion, this pattern serves as a powerful reminder of the importance of courage, curiosity, and continuous learning in the development of one’s craft. By embracing a beginner’s mindset, craftsmen can unlock new possibilities, foster innovation, and ultimately reach greater levels of mastery in their chosen fields.

From the blog CS@Worcester – Eli's Corner of the Internet by Eli and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective #3

Overall, I believe the second sprint went well. Like the previous sprint, we had meetings in person or over discord. All in all, I believe we all did a fantastic job of keeping each other updated and asking each other questions when we got stuck. I noticed that once we finished one issue, nobody hesitated to start another issue which really helped us with moving the project along. During this sprint, we worked on several of the issues as a group. We kept up the open-mindedness, accountability, honesty, and respect that were originally described as the culture we hoped to establish in the working agreement. Like in the previous sprints, we determined the maximum amount of work that each person should attempt to finish in order to split the work fairly and equally in regards to the issues we had, and we mostly adhered to it.

I worked on multiple issues that involved verifying that the pantry projects had the correct extensions, linters, and pipeline stages. Like the last sprint, I looked over the project’s file types, created a list of required linters based on the files, added any new linters, verified that the new linters passed, verified which stages were required, and adjusted the stages as necessary. For this type of issue, I worked on “Verifying that all Thea’s Pantry projects have the correct extensions, linters, and pipeline stages – InventorySystem General” by myself and then worked on “Verifying that InventoryAPI has the correct extensions, linters, and pipeline stages” and “Verifying that all Thea’s Pantry projects have the correct extensions, linters, and pipeline stages – Inventory Backend” with the group. When working on the issue for InventorySystem General, I realized that the build and test scripts weren’t needed so I also removed those files. I also worked on “Determine what needs to be done on GuestInfoFrontend” with the group. For this issue, we reviewed comments left in the code, wireframe, and documentation. Then if any work worthy of note needed to be done, we created new issues for them. We created these issues (“Moving “Other Assistance” attribute” and “Moving Receiving Unemployment Attribute to Assistance”) and linked them to the initial issue. 

I think we did really well as a team for this sprint. We did not get around to establishing a method that will guarantee that particular individuals are not examining the majority of issues, as we had originally intended when drafting our working agreement. For this sprint, we did not discuss how we would make sure to stay on top of issues that needed to be reviewed because many of the issues included us working together and we stayed on top of a lot of the issues. The time frame between finishing an issue, reviewing, and merging was a lot shorter than the last sprint. We made sure to constantly communicate with each other and the first one that could review an issue took the task. As a group, I can see that we improved a lot in that regard but I still think we could establish a method to make sure that reviewing code is not done mainly by a few individuals in the group. As an Individual, I showed a lot of improvement by checking on what needs to be done compared to the previous sprints but I think I can still improve when it comes to merging my issues as quickly as possible after they’ve been reviewed.

From the blog CS@Worcester – Live Laugh Code by Shamarah Ramirez and used with permission of the author. All other rights reserved by the author.

Understanding Object-Oriented Testing

In the realm of software development, testing plays a crucial role in ensuring the reliability, functionality, and quality of the final product. As software systems become increasingly complex, traditional testing methods may not suffice, particularly in object-oriented (OO) programming environments. This blog explores the intricacies of OO testing and its significance in software engineering practices.

Summary of Object-Oriented Testing

Object-oriented testing focuses on validating the interactions, behaviors, and integrity of objects, classes, and their relationships within an OO system. Unlike traditional testing methods that primarily test individual functions, OO testing addresses the unique challenges posed by OO programming, such as data dependencies, inheritance, polymorphism, and dynamic binding.

The blog outlines various techniques used in OO testing, including:

  • Fault-based testing: Identifying faults in the design or code and creating test cases to uncover errors.
  • Class testing based on method testing: Testing each method of a class to ensure its functionality.
  • Random testing: Developing random test sequences to mimic real-world scenarios.
  • Partition testing: Categorizing inputs and outputs to test them thoroughly.
  • Scenario-based testing: Stimulating user actions to test interaction patterns.

Moreover, the blog highlights the purposes of OO testing, such as validating object interactions, identifying design errors, assessing code reusability, handling exceptions, and maintaining system uniformity.

Purpose of Object Oriented Testing

  1. Object Interaction Validation: Ensure that objects interact appropriately with each other in various situations.
  2. Determining Design Errors: Identify limitations and faults in the object-oriented design, focusing on inheritance, polymorphism, encapsulation, and other OOP concepts.
  3. Finding Integration Problems: Evaluate an object’s ability to integrate and communicate within larger components or subsystems, locating issues such as improper method calls or data exchange problems.
  4. Assessment of Reusable Code: Evaluate the reusability of object-oriented code, ensuring that reusable parts perform as intended in different scenarios, leveraging features like inheritance and composition.
  5. Verification of Handling Exceptions: Confirm that objects respond correctly to error circumstances and exceptions, ensuring the software is resilient and durable.
  6. Verification of Uniformity: Maintain consistency within and between objects and the overall object-oriented system, enhancing maintainability and readability by following naming standards, coding styles, and design patterns.

Personal Reflection

While traditional software testing emphasizes system-level functionality and performance, object-oriented testing focuses on validating interactions and behaviors within OO systems. Both resources underscored the importance of rigorous testing in software engineering, albeit with different approaches.

In my future practice, I intend to incorporate elements from both traditional and object-oriented testing methodologies. By applying fault-based testing, random testing, and scenario-based testing techniques from OO testing, I aim to identify and rectify potential errors early in the development process. Additionally, I will continue to emphasize comprehensive system testing to ensure software meets user requirements and quality standards.

Understanding both traditional and object-oriented testing methodologies equips me to contribute effectively to the creation of high-quality software solutions. By integrating the insights gained from both resources, I am confident in my ability to enhance software testing practices and deliver reliable software products in today’s dynamic software development landscape.

Source: https://www.geeksforgeeks.org/object-oriented-testing-in-software-testing/

From the blog CS@Worcester – CS: Start to Finish by mrjfatal and used with permission of the author. All other rights reserved by the author.