Category Archives: CS@Worcester Blog

Sprint 3 Retrospective

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-category-based/frontend/-/blob/main/src/frontend/src/components/UPCScanner.vue?ref_type=heads

This is the link to sendBarcodeToBackend method that I implemented.

What Worked Well

This sprint, I focused heavily on developing a method where the the detected barcode will automatically send a GET request to the backend, establishing a form of communication from the frontend to the backend. I used the native BarcodeDetector API, which allowed me to avoid external dependencies and keep the code lightweight. The automatic fetch to the backend based on a detected barcode worked exactly as expected, and it felt satisfying to see a 200 ok status in the browser’s network tab confirming backend communication. Our Git workflow also went smoothly , I was able to create feature branches, merge through merge requests, and pass all pipeline checks without major issues.

What Didn’t Work Well

Initially, I attempted to send the barcode data to the backend using a POST request, assuming it was the right choice. However, the backend only supported a GET route, which led to a 404 error. It took some time to trace the problem, especially because no error message appeared visually in the UI. Additionally, I had trouble with Git merge conflicts after another teammate merged changes to main before mine. I had to learn how to pull the latest from main, resolve .cspell.json dictionary conflicts, and push again.

Team Improvements
As a team, we could communicate more consistently during merges. There were moments when teammates worked on overlapping files without letting others know, which resulted in Git conflicts. We can improve by checking in more frequently on Discord or maintaining a better shared task board to reduce surprises and overlapping edits.

Personal Improvements

I want to get better at anticipating backend constraints , such as which methods (GET, POST) are actually available. I also want to be more proactive about asking teammates before starting work on shared components like the router or layout. In the future, I’ll aim to do smaller commits more frequently and leave helpful comments for reviewers so my merge requests are easier to understand and approve.

Apprenticeship Pattern: “Record What You Learn”

Summary:
This pattern encourages developers to keep a personal record of lessons, mistakes, workarounds, and discoveries during their learning journey , whether in a journal, blog, or notes folder.

Why I Chose This Pattern:

During this sprint, I encountered several learning moments , like how to properly use environment variables (VITE_API_URL), how to avoid hardcoding backend URLs, and how to debug merge conflicts. These are things I could easily forget if I don’t document them. I started keeping a small dev log after reading this pattern, and it’s already helping me.

How It Would Have Helped Earlier:

If I had followed this pattern from the start, I could’ve avoided wasting time retracing my steps when I forgot how I handled similar problems earlier in the sprint. I would have written down how I fixed the fetch issue with the GET request or how I resolved markdownlint errors. That would’ve also made it easier to share knowledge with teammates during check-ins.

From the blog CS@Worcester – Software Dev Capstone by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Implementing the Low Stock Alert System – Reflections from Sprint-3

During Sprint-3, I focused on building and refining a critical feature for our inventory management backend: a low stock alert system. Alongside this, I dedicated time to improving project documentation and maintaining clarity in code contributions. This sprint challenged both my technical implementation skills and my ability to communicate system behavior effectively for team collaboration.

What Was Implemented

The low stock alert system was designed to run once daily at 10 AM on weekdays, checking if any products in categorized_database.json had dropped below their respective minimum stock threshold. If a product was low, an email alert was automatically triggered using nodemailer and Gmail’s SMTP service.

To ensure this didn’t overload the system, I used a time-gated setInterval() inside index.js that only allowed email triggers if the day was between Monday and Friday and the hour equaled 10. The function checkAndSendLowStockAlert() in stockAlert.js handled the core logic and email composition.

Documentation Work

I also spent significant time documenting:

  • Purpose and responsibilities of the new stockAlert.js module.
  • Integration lines in stockAlert.js showing how and when the alert system executes.
  • Comments in code explaining each logic block.
  • A issue description called Low stock product alert covering everything from cron-like scheduling logic to pending Gmail credentials that require updates for the system to function securely.

GitLab Activity Highlights

What Worked Well

  • Modularization: Separating the alert system logic from index.js into its own file (stockAlert.js) helped maintain clean code structure and made debugging much easier.
  • Scheduled execution: Implementing a weekday/time condition made the feature realistic for workplace use and prevented unnecessary system loads.
  • Collaborative Documentation: Keeping a running commentary in GitLab merge requests helped the team understand changes quickly and facilitated smooth peer reviews.

What Didn’t Work Well

  • Gmail integration required an app password and correct permissions. The first few test runs failed due to missing or incorrect credentials.
  • Initial testing limitations: Since the alert only triggers once per day at 10 AM, simulating scenarios for rapid testing was a challenge.
  • Delayed implementation of logging: Early iterations lacked logs or fallbacks, making failures harder to trace.
  • After talking to professor Karl, he wanted to the server to handle this, so an issue was created so it alert can be server-handled task.

What Could Be Improved as a Team

  • Create a shared .env or config file that can be used across modules instead of hardcoding emails or thresholds.
  • Develop a simulation mode to test time-bound functions instantly, especially for scheduled jobs.
  • Review and testing sessions could be more frequent and planned earlier in the sprint.

What Could Be Improved as an Individual

  • I should’ve created mock data and test harnesses sooner to simulate alerts without waiting for specific days or times.
  • Next time, I’ll also write unit tests for alert logic to ensure that key conditions are evaluated correctly.
  • I should’ve been quicker to document issues with the Gmail setup and create a checklist for anyone running the alert system in another environment.

Apprenticeship Pattern: “Breakable Toys” (Chapter 3)

Summary: The “Breakable Toys” pattern encourages developers to build small, personal projects that simulate real-world systems, allowing them to make mistakes safely and learn without real consequences.

Why I Chose It: This pattern resonated deeply with my experience during the sprint. The low stock alert feature was like a small “toy system” that had the same structure as production-level alert systems (scheduled jobs, email APIs, condition checks) but existed in a controlled environment.

Relevance: During this sprint, I often wished for a sandboxed copy of our inventory system just to run quick iterations. The constraints of the main codebase slowed experimentation. Had I consciously embraced the “Breakable Toys” mindset earlier, I could have built a parallel mini-system that isolated alert logic and Gmail testing—speeding up development and reducing risk.

How It Would’ve Helped: Reading this pattern in advance would have prompted me to:

  • Clone and strip down the inventory codebase into a test script.
  • Avoid introducing bugs into the primary system.
  • Feel more confident experimenting with cron-style scheduling and async email logic.

Low Stock Alert System

From the blog cs@worcester – A Journey through CS by mgl1990 and used with permission of the author. All other rights reserved by the author.

Sprint 1 Retrospective Blog Post

As a Computer Science major in my final year of college, I thought I had learned everything I needed to know. However, my Software Development Capstone class has proven me wrong. I’ve realized there’s still so much to learn, especially when it comes to working in a team and building a project from scratch. My team and I were tasked with creating a system to improve the University’s food pantry inventory management. This project has been both challenging and rewarding, and Sprint 1 was a great starting point for our journey.

GitLab Evidence

Throughout Sprint 1, my partner and I focused on creating the frontend prototype for the barcode scanner. Below are the links to our GitLab activities, along with a brief description of each:

  • Initial Front Page:
    GitLab Issue #7
    Description: Created the initial front page using HTML and CSS.
  • Scanner Page:
    GitLab Issue #9
    Description: Created the scanner page using HTML, CSS, and JavaScript to implement the barcode scanner.
  • Barcode Scanning Functionality:
    GitLab Issue #10
    Description: Implemented the html5-qrcode library to enable barcode scanning functionality.
    Library Link: html5-qrcode GitHub
  • Displaying UPC Results:
    GitLab Issue #11
    Description: Modified the scanner page to display the results of the UPC.
  • Aesthetic Improvements:
    GitLab Issue #12
    Description: Improved the aesthetics of the front page (index.html) and scanner page (scanner.html) by updating the color palette and fonts.

Despite being strangers at the beginning of the semester, my team has worked together seamlessly. We communicate effectively, both in and out of class, and support each other not only in this project but also in our other classes. Everyone feels comfortable asking questions and sharing ideas without fear of judgment, which has created a chill and productive atmosphere. Additionally, our scrum master assigned us to sub-teams, and each member knew exactly what they needed to do. This clarity helped us stay organized and focused.

While we used GitLab to track issues, we could have utilized it more effectively. For example, we sometimes forget to update issues or document progress in detail. Also, since my partner and I were new to frontend development, we spent a lot of time learning the basics of HTML, CSS, and JavaScript, which slowed down our progress initially. In Sprint 2, we plan to use GitLab more effectively to track issues, as we discussed during sprint planning. My team and I will make a conscious effort to update GitLab issues regularly and document our progress more thoroughly. This will help us track our work more effectively, avoid confusion, and ensure that everyone is aligned on the tasks and their status.

I want to dedicate more time outside of class to learn frontend technologies. This will help me contribute more effectively to the project and build a stronger foundation for my future career. In Apprenticeship Patterns by Dave Hoover and Adewale Oshineye, the pattern “The Long Road” emphasizes the importance of committing to a lifelong journey of learning and mastery. It encourages aspiring software craftsmen to focus on long-term growth rather than chasing quick success, promotions, or material rewards. The pattern reminds us that mastery takes time and that we should embrace the journey, even if it means being seen as unconventional. I selected this pattern because it resonated deeply with my experience during Sprint 1. As someone who is new to frontend development, I felt overwhelmed at times by how much I still needed to learn. However, this pattern reminded me that mastery is a gradual process and that I shouldn’t compare myself to others who may seem further ahead. It also reinforced my desire to focus on frontend development as a long-term career path, even if it means taking the time to build a strong foundation. If I had read this pattern earlier, I would have approached Sprint 1 with more patience and confidence. Instead of feeling pressured to produce quick results, I would have focused on learning and improving my skills at a sustainable pace. This mindset would have helped me enjoy the process more and reduce the stress of trying to catch up to others.

From the blog CS@Worcester – CodedBear by donna abayon and used with permission of the author. All other rights reserved by the author.

The beginning of a Journey of a Software Craftsman: Reflections on Chapter 1 of Apprenticeship Patterns

The path to becoming a skilled software developer is not just about learning programming languages or mastering frameworks—it’s about embracing a mindset of continuous learning, humility, and craftsmanship. Chapter 1 of Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman by Dave Hoover and Adewale Oshineye sets the foundation for this philosophy, introducing readers to the idea of software development as a lifelong journey of growth.

One of the most compelling aspects of this chapter is its focus on the concept of apprenticeship in software development. Unlike traditional education or even structured corporate training, an apprenticeship mindset encourages developers to seek knowledge actively, engage with mentors, and build real-world experience through deliberate practice. The book compares software craftsmanship to traditional guilds, where newcomers learn by doing, gradually refining their skills under the guidance of experienced practitioners.

The emphasis on deliberate practice particularly resonated with me. It’s easy to fall into the trap of writing code every day and assuming that practice alone leads to mastery. However, the book suggests that true improvement comes from purposeful and reflective practice—analyzing mistakes, challenging oneself, and continuously pushing the boundaries of one’s abilities. This idea shifted my perspective on how I approach learning new technologies and refining my existing skills.

Before reading this chapter, I viewed my professional growth in software development as something that happens naturally over time—an accumulation of experience gained from projects and exposure to different technologies. However, Apprenticeship Patterns made me realize that growth must be intentional. It’s not enough to just work on projects; I need to actively seek out challenges, solicit feedback, and set concrete learning goals to accelerate my progress.

Another takeaway that impacted my mindset is the importance of humility. The book stresses that being a software craftsman requires accepting that there will always be more to learn. I found this particularly valuable because it aligns with the idea of the beginner’s mind—approaching every problem, regardless of experience, with curiosity and openness rather than arrogance.

P

While I found the chapter insightful, one point that I questioned was the romanticization of apprenticeship as a primary learning model. While mentorship and hands-on learning are invaluable, not everyone has access to experienced developers willing to guide them. In today’s fast-paced software industry, many developers are self-taught through online courses, coding boot camps, and open-source contributions. While the book acknowledges that different learning paths exist, I think it could have placed more emphasis on alternative ways to develop craftsmanship outside of the traditional mentor-apprentice model.

Which Chapters Seem Most Relevant?

From a quick glance at the table of contents, the chapters that seem most relevan that caught me:

  • This seems crucial for maintaining motivation and engagement in the field. Passion is what drives deep learning.
  • I’m interested in how the book suggests balancing learning new, complex topics while also reinforcing foundational skills.
  • This chapter likely discusses the tension between personal growth as a developer versus career advancement, a topic that resonates deeply with me as I navigate my own path.

Chapter 1 of Apprenticeship Patterns offers an inspiring and thought-provoking perspective on how to approach software development as a lifelong craft. It reinforced my belief that learning should be intentional and reflective, and it pushed me to think about how I can structure my growth more effectively. While I don’t entirely agree with every aspect of the apprenticeship model, I appreciate the book’s emphasis on continuous improvement, humility, and the importance of deliberate practice.

For aspiring and experienced developers alike, this book serves as a guide to not just writing better code, but becoming a better craftsman in the art of software development.

From the blog Discoveries in CS world by mgl1990 and used with permission of the author. All other rights reserved by the author.

AI Revolutions in Large-Scale Application Development

The advent of Artificial Intelligence (AI) is changing the software development landscape, making the creation of big project and their related application code faster, smarter, and more efficient. From automating repetitive tasks to optimizing code and enabling predictive analysis, AI empowers developers to achieve more with less effort. This blog explores how AI actual facilitated in normal coder and tester related workers and their tangible benefits give more reliable outcomes without any more works.

               AI acts as a force multiplier in software development, streamlining workflows, reducing errors, and enhancing productivity. Before AI the possibilities of traditional works are very lengthy and so much effort of manual strategy, particular for large projects. By using machine learning, natural language processing, and advanced algorithms, AI tools and platforms help developers at every stage of the application lifecycle, thus easing those challenges.

Key Areas where AI Growing:

Code Generation: In GitHub Copilot AI tools helps developers by generating raw codes, suggesting snippets, and writing full code according to their descriptions.

Bug Detection and Fixing: AI tools like Deep Code analyses coders code and give accurate and deeper result so it gives actionable recommendations in real bugs and fixes their uses in just one click.

Automated Testing: Machine learning algorithms can generate large scale test on minimum time so it actual carry the whole process testing in their application so workers can get time and effortless comprehensive testing.

Real-World Examples of AI in Action

  1. GitHub Copilot: This AI coding assistant generates suggestions in real time, helping developers write efficient and accurate code faster. It makes big projects easier to handle by lowering the amount of manual labor required for repetitive coding chores.
  2. Chatbots for DevOps: AI-powered chatbots doing multiple things automatically like server deployment, monitor application health, and resolve issue in one time so human interventions growth reduced.

Challenges and Limitations is also part of this AI skills. AI-generated code may require careful validation so might be Accuracy Dependence is requirement in project-specific parts. It may be necessary to make an initial training expenditure in order for developers to comprehend how to use AI tools efficiently. Using AI in proprietary projects brings up issues related to biassed algorithms and intellectual property so ethical issue is also fixed it our terms and modifications.

               As AI continues to evolve, its role in software development will expand further. Innovations such as generative AI for full-stack applications, intelligent debugging systems, and adaptive learning platforms will redefine what’s possible in large-scale application development. In conclusion, AI is not just a tool for coders; it is one robot which give accurate result without any further large skills task. Diverse controlling in AI based application is sometime give innovation and creativity and every computer fields.

Citations:

  1. GitHub Copilot Documentation. (n.d.). https://github.com/features/copilot
  2. Amodei, D., Olah, C., et al. (2016). Deep Learning in AI Systems. OpenAI Research Papers.
  3. Applitools AI Testing Tools. (n.d.). https://applitools.com
  4. How AI is Revolutionizing Software Development [YouTube Video]. (2023). Available at: https://www.youtube.com/watch?v=IGQChbLYFqY

From the blog CS@Worcester – Pre-Learner —> A Blog Introduction by Aksh Patel and used with permission of the author. All other rights reserved by the author.

GitHub and Docker: Streamlining Database Management for Modern Development

In AI based fast growing world of software development, very deep knowledge database management plays a pivotal role in ensuring application performance and scalability. GitHub and Docker have become indispensable tools for developers, providing streamlined workflows and efficient environments for database development, testing, and deployment. This blog explores how GitHub and Docker work together to simplify database management in today’s world.

GitHub, a leading platform for version control and collaboration, is key part is managing database code, schemas, and migration. For hosting configuration files, and database-related repositories, GitHub using one source to get maximum database workflows. GitHub also fulfill the software tester and developer related tools to easy to convert code and data process without any lengthy process. Giving branching, pull request, and code reviews facilities actually make GitHub performances very advanced in machine learning world. Version control with actual data track with their schemas, collaboration with multiple contributors and Integration with CI/CD Pipelines provides key benefits of GitHub database. Where Docker, the development and testing of databases is being transformed by a packaging platform. Docker enables developers to reproduce production-like environments on local computers by enclosing databases within containers, guaranteeing stability across the stages of development, testing, and deployment. Environment Consistency, Isolated containers and scalability provide key features of docker which give real support in testing team so we can easily grow with our GitHub system.

When combined, GitHub and Docker provide a robust solution for managing database workflows.

  1. Versioning and Collaboration with Docker Files:

Docker files and Compose files, essentials for databases, are stored in GitHub repositories. Developers can version-control these files, and automate container builds via GitHub Actions.

2. Automated Testing:

Developers can easily supply files with version control and creating pipelines so spin up actual data for their multiple automated testing.

3. Database Migrations as Code:

Teams store migration scripts in GitHub, while Docker containers provide isolated environments to test these scripts. Reliable schema modifications in staging and production settings are guaranteed by this method.

Advantages of Using GitHub and Docker for Databases:

Reduced Onboarding Time: Learners can start working with prebuilt Docker containers without any work delays.

Improved Testing: Automated tests run against containerized databases, ensuring thorough validation of database changes.

Enhanced Collaboration: Efficient team workflow, while Docker guarantees consistency of the surroundings.

In conclusion, GitHub and Docker together form a powerful duo for modern database management, addressing challenges like environment consistency, version control, and collaboration. For small project to build large applications these two combos give detailly work and improving features in all workers. GitHub and Docker will continue to redefine how databases are managed in the software development lifecycle.

Citations:

  1. GitHub Actions Documentation. (n.d.). https://docs.github.com/en/actions

2. Docker Documentation. (n.d.). https://docs.docker.com

From the blog CS@Worcester – Pre-Learner —> A Blog Introduction by Aksh Patel and used with permission of the author. All other rights reserved by the author.

Software Testing Circumstances

Software testing is crucial phase of the software development cycle. After numerous errors and choices have been made, this entire approach functions in a single manner. However, the effectiveness and efficiency of software testing are significantly influenced by the circumstances in which it is conducted. After we finish the software testing phase, there are still issues that arise despite the extensive critical thinking and methodology. The term “software testing circumstances” refers to the conditions and environments in which testing occurs. These conditions include a number of elements, including financial constraints, time limits, team experience, technological infrastructure, and the development technique adopted. Testing is scheduled in accordance with their execution and development procedure based on critical situations.

Key Challenges in Software Testing Circumstances:

  1. Time Constraints

Some tasks are ruined by tight deadlines, but other tools can help your complete tasks more quickly. Ultimately, how you do your work under intense pressure depends on how you handle time limitations.

2. Limited Resources

Insufficient resources, such as skilled personnel, testing environments, or financial backing, can restrict testing scope. Some resources offer extra help with the task at hand, but the testing scenario’s limited resources have impeded your work and stopped you from resolving their problems so you can continue testing.

These Two is key problem we see in every testing problem.

Adapting to Testing Circumstances:

  1. Prioritization with Risk-Based Testing

Teams can allocate resources efficiently by focusing on important capabilities and identifying high-risk areas. This guarantees that, despite limitations, crucial functions are adequately tested.

2. Early Involvement of Testing Teams

Engaging high skills testers from the beginning of the work is give reliable and accurate result and give balancing the whole cycle in testing phase.

3. Cloud-Based Testing Environments

Without requiring a significant upfront infrastructure investment, cloud testing methods provide scalable and wide-ranging testing environments. By simulating actual circumstances, these technologies increase coverage.

These are fundamental abilities we master in our cycle to get deeper and faster results with the time we need for essentials.

Our testing encounters little errors that can be resolved with minor adjustments, so we lower the testing error graph. AI-driven technologies assist us in our performance section, allowing us to draw our testing error cycle without requiring a large expenditure.

               In conclusion, Problems involving software testing can cause difficulties, but these can be successfully avoided with preemptive measures and modern tools. Understanding and adapting to the nuances of each testing scenario is key to maintaining reliability and user satisfaction.

Citations:

  1.  Myers, G. J., Sandler, C., & Badgett, T. (2011). The Art of Software Testing. Wiley.
  2.  ISTQB Foundation Level Syllabus. (n.d.). https://www.istqb.org
  3. Atlassian Continuous Testing Guide. (n.d.). https://www.atlassian.com/continuous-testing
  4. IEEE Software Testing Standards. (n.d.). https://www.ieee.org

From the blog CS@Worcester – Pre-Learner —> A Blog Introduction by Aksh Patel and used with permission of the author. All other rights reserved by the author.

Version Control apply in cooperative work VS Student life

Each organization in the modern world invests thousands of dollars in Agile development. Agile offers a lot of advantages, but the business only creates successful tactics, and version control is one of them. For computer science students, becoming proficient in Agile not only increases your hands-on expertise but also helps you master your surrounding team environment.

Version control and Agile methodology give you more power for your frequently changing things. This principle provides quick adaptation and mastery in changing technology, so every team manager can robustly improve their performance with a good mindset. Chances in everyday situations also play a part in our tasks as a team. Agile is simply one technique; your team’s performance depends on more than just one mindset. It affects our environment’s inevitable glitches and bugs. It also upgrades one mindset through team-leading performances. Quick adaptation is also most crucial role play in student academic career. How fast you adopt things and applied it that things in right place with good understanding gives more benefits in your career goals. Today’s world is not steady because everyday life changing and new things come and go so adaptation according to chances is play key role in every sector. Students want to know how agile control flow their mind in different scenario. Version control allows students to create real-world scenarios in which multiple team members work on various parts of a project at the same time.

Key Benefits for Students

Enhanced Collaboration – Version Control enables students to work on multiple group activities in one time and also check their work and give meaningful work problems skills optimizations so students can easily learn multiple things in a single time and apply it in the job market.

Timing Ability – Focus on their project evolution completed in a proper way with time to time is implementing a tracking system and accountability. This not only helps with understanding the development timing but also cultivates a sense of accountability for program improvements.

Developing To Take Risk Ability – New ideas working in their plans without fear it’s creating a more advanced process. This encourages new modern art, helps to solve your error, and enhances your taking ability skills. 

In conclusion, vision control in Agile is powerful in the cooperative and student worlds. These benefits help a lot in your future career processes, so applying them with proper thinking creates delivery methods and boosts your career. Students helps these advanced weapons in the real world, so learning and understanding the whole process makes humans more powerful.

November 29, 2024

From the blog CS@Worcester – Pre-Learner —> A Blog Introduction by Aksh Patel and used with permission of the author. All other rights reserved by the author.

Starting the year off!

Welcome to my first blog post! My name is Andi Cuni and I am a senior completing my undergraduate CS degree. Starting my journey blogging with a background in computer science and software development, I am excited for this transition, and I plan to share everything that comes along my experiences to see if others relate as well!

From the blog CS@Worcester – A Day in the Life as a CS Blogger by andicuni and used with permission of the author. All other rights reserved by the author.

Learning How We Fail Until We Hit Growth

Hey Everyone! In the nonstop pursuit of excellence, the “Learn How You Fail” pattern reminds us of a old forsaken truth: failure is not a curse but a catalyst for growth. It challenges us to confront our weaknesses head-on, to seek out the patterns and behaviors that lead to our missteps, and to use that self-knowledge as a powerful tool for transformation.

The whole point of this pattern means a lot to me deeply, as it recognizes that true creativity and work ethic are not born from a quest for perfection but actually a willingness to form somewhat of a imperfection. As Atul Gawande states, “Ingenuity is often misunderstood. It is not a matter of superior intelligence but of character. It demands more than anything a willingness to recognize failure, to not paper over the cracks, and to change.”

Personally, I find this pattern both humbling and it gave me a sense of confidence. After reading it a couple of times, it forces us to confront the uncomfortable reality that our successes are often counterbalanced by our failures and weaknesses. I’ve always related to the fact that you have to get out of the comfort zone otherwise you’ll stay there forever. Reason is, in that discomfort is the seed of growth – by consciously acknowledging our limitations, we open ourselves to the possibility of going past them.

This pattern has profoundly influenced my perspective on the intended profession. It has reinforced the idea that your craft is not a destination but a continuous journey of self-discovery and self-improvement. By embracing the idea of “learning how we fail,” we create a mindset of resilience and adaptability, qualities that are essential in the ever-evolving landscape of software development, especially after reading about these patterns.

One aspect of the pattern that resonates particularly is the hard point on making conscious choices. By gaining self-knowledge about our patterns of failure, we empower ourselves to make informed decisions, sort of how some work better under pressure– whether to work on fixing those weaknesses or to acknowledge our limitations and focus our efforts elsewhere.

Lastly, the “Learn How You Fail” pattern is a powerful reminder that failure is not an enemy to be feared but a guide to be embraced. It is a call to take in vulnerability, to find the illusion of perfection, and to strive as more self-aware, adaptable, and the best version of ourselves we can be in and out of software development.

andicuni
May 15, 2024

From the blog CS@Worcester – A Day in the Life as a CS Blogger by andicuni and used with permission of the author. All other rights reserved by the author.