Chapter 3 of “Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman”.

In Chapter 3 of “Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman,” entitled “Walking the Long Road,” the focus lies on recognizing that achieving mastery in fields like software development is a gradual process demanding persistence, endurance, and ongoing education.


The chapter opens by stressing the importance for aspiring craftsmen to accept that attaining mastery is not an immediate goal but rather a journey that unfolds over time. It underscores the comparison to a lengthy road trip, where the adventure itself holds equal importance to reaching the final destination. This change in mindset is essential for newcomers to the realm of software development, aiding them in valuing the journey of honing their skills and achieving expertise.


Following this, the chapter presents the “Long Road” pattern, advocating for prioritizing long-range growth over pursuing immediate rewards or quick fixes. It stresses the significance of establishing realistic objectives, fostering a mindset of continuous improvement, and dedicating oneself to regular practice and enhancement of skills throughout the journey.


An interesting element of this chapter lies in its focus on the importance of persistence and fortitude when confronted with difficulties and setbacks. It underscores the certainty of facing obstacles during the pursuit of mastery and urges readers to perceive these challenges as chances for personal development rather than excuses to surrender.


Additionally, the chapter offers actionable guidance on effectively traversing the lengthy journey. It recommends approaches like seeking mentorship, engaging with communities of practitioners, and embracing intentional practice to expedite the process of learning and skill refinement.


In summary, Chapter 3 of “Apprenticeship Patterns” underscores the essential components of achieving mastery in software development, emphasizing the need for commitment, endurance, and an appreciation for the process. By embracing the philosophy of “walking the long road” and heeding the chapter’s advice, aspiring software craftsmen can embark on a journey toward ongoing advancement and eventual expertise in their field of choice.

Ultimately, this pattern can inspire a more sustainable and fulfilling approach to your intended profession, one that emphasizes continuous learning, resilience, and a commitment to long-term improvement.

Sprint 2 planning


Throughout our team discussions, we addressed several key points:

Some tasks (OL-1) weren’t completed by another group, who claimed they were done or unnecessary. We need to inform the professor (#26).

We need to ensure that the guestinfofrontend knows which server address it’s using. Adjusting the Gitpod ci.yaml file can help with this.

The backend server is encountering issues and isn’t running properly, especially affecting weight increment functionalities.

Creating a Gitpod initialization task will automate setting up the workspace’s address, streamlining our workflow.

We should utilize environment variables to manage URLs, distinguishing between local and Gitpod environments for better configuration.

Setting a backend base URL will prevent hardcoding and make it easier for the frontend to access.

We need to troubleshoot module not found errors, which may be related to exports or syntax issues.

Enhancing our debugging capabilities with JavaScript tools will improve error detection and resolution.

Conducting experiments and documenting findings will help guide our future actions and decisions.

Thorough documentation is crucial for the benefit of future teams, especially if time is limited.

We must prepare for presentations during exams, focusing on showcasing our team’s progress.

Improving our planning and testing processes will lead to smoother project execution and fewer setbacks.

Providing clear integration examples and deployment instructions will facilitate seamless implementation.

Utilizing collaborative tools will enhance efficiency in task management and communication.

Lastly, we should compile promising solutions into a shortlist for further evaluation and consideration.

Chapter 2 of “Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman”.



In Chapter 2 of “Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman,” called “Emptying the Cup,” the focus is on the notion that effective learning requires individuals to recognize and accept their current shortcomings and biases. The chapter emphasizes the significance of maintaining an open mind and welcoming new concepts, even when they contradict what one already knows.


In the opening of the chapter, the idea of an “empty cup” is explained using a story about a martial arts student who seeks guidance from a master. However, the student’s mind is already filled with his own beliefs and assumptions, making it difficult for the master to impart knowledge effectively. The student must metaphorically empty his cup, shedding his preconceived notions, to be receptive to genuine learning.


The key lesson is to embrace humility and openness in career advancement, acknowledging constant room for improvement and discarding outdated habits, assumptions, and biases to facilitate growth.

The chapter offers useful guidance on how to embrace the concept of “emptying the cup” by urging readers to actively pursue experiences that push the boundaries of their current understanding and beliefs. This might entail taking on projects that are unfamiliar, soliciting input from colleagues, or deliberately practicing to enhance skills in weaker areas.


What’s interesting about this chapter is its emphasis on the importance of mindset in the learning process. It underscores that achieving mastery isn’t solely about amassing information and abilities, but also hinges on cultivating a receptive attitude toward learning and development. Embracing the notion of the “empty cup,” readers are motivated to approach their evolution as software craftsmen with curiosity, humility, and an open-minded outlook.


This chapter proves useful as it provides actionable methods for overcoming cognitive biases and constraints that may hinder personal development. By acknowledging the significance of embracing new perspectives, readers can foster a mindset conducive to ongoing progress and expertise. This approach can enhance creativity, innovation, and effectiveness in software development, while also fostering personal fulfillment and satisfaction in one’s professional endeavors. Ultimately, “Emptying the Cup” serves as a beneficial reminder of the essential role humility and open-mindedness play in striving for excellence.


Reflecting on Chapter 2 of “Apprenticeship Patterns,” I recognize the need to critically assess my choice of programming language. Considering factors like ecosystem, learning style alignment, and industry relevance, I understand that my initial assumptions may require reassessment. Embracing this change in perspective prompts a more intentional approach to learning, potentially leading to greater mastery and fulfillment in my profession.

Chapter 4 of “Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman” focuses on the concept of “Confront Your Ignorance.”

This chapter highlights that acknowledging your limitations is key to growth. It offers a roadmap for identifying these gaps and strategies for filling them.

The chapter lays the foundation with the Dreyfus Model, a roadmap for skill development. It breaks down learning into five stages: Novice, Advanced Beginner, Competent, Proficient, and Expert. The authors emphasize understanding your current level and adopting a lifelong learning mentality.

Imagine your skills and experiences as a developer stacked together, like a toolbox. This toolbox is your “knowledge portfolio.” The chapter argues that for a successful, long-lasting career, you shouldn’t just have a hammer. Instead, aim to be a “generalizing specialist.” This means having a go-to tool (deep expertise) but also filling your toolbox with various other useful tools (proficiency in diverse areas). This versatility allows you to tackle more problems and adapt to changing needs in the software-development world.

The chapter outlines several strategies for effectively addressing your ignorance:

  1. Build a Solid Foundation: Focus on mastering the fundamentals of your field. A solid foundation will prepare you for more advanced learning and future growth.
  2. Learn How You Fail: Reflect on past experiences, both successes and failures, to identify areas where you can improve your knowledge. Use these insights to guide your future learning.
  3. Expose Your Ignorance: Accept that you’re still learning and don’t be afraid to admit you don’t have all the answers. See your knowledge gaps as steppingstones to becoming a master.
  4. Confront Your Ignorance: Don’t shy away from opportunities to learn. Ask questions, take classes, and constantly seek out new information to fill in the gaps in your understanding.
  5. Find Mentors: Seek out experienced individuals who can mentor you and share their knowledge. A good mentor can offer valuable advice and insights based on their own experiences.

The interesting and useful concerns about this chapter is it discusses the importance of recognizing and accepting that you don’t know everything. It encourages embracing your ignorance as a steppingstone to learning and growth.

This chapter has changed the way i think about my profession as it emphasizes the importance of continually learning and expanding your skills beyond just coding. It suggests that software development is not just about writing code but also about understanding the business domain, interacting with customers, and collaborating effectively with others.

In essence, Chapter 4 of “Apprenticeship Patterns” emphasizes the significance of admitting what you don’t know as a software developer. By recognizing your boundaries and actively pursuing chances to learn and improve, you can strengthen your abilities and progress in your software development career.

Sprint retrospective

Our team has reflected on our recent project experiences and identified areas where we can strengthen our collaboration to improve project outcomes. Here’s a breakdown of what worked well and what didn’t, along with proposed changes for improvement:

Successes:

  • We successfully completed a significant portion (75%) of small tasks.
  • Our meetings were productive, fostering meaningful discussions.
  • Communication among team members was clear and effective.

Challenges:

  • Difficulty with Docker-compose and documentation tasks due to inaccurate task weighting.
  • Essential details were not easily accessible, often buried within overarching epics.
  • Task distribution among team members was uneven.
  • Overreliance on one team member for handling GitLab logistics.
  • Limited collaborative assistance on individual issues.

Proposed Team Improvements:

  • Foster a culture of teamwork by encouraging mutual assistance on tasks.
  • Assign task weights more accurately based on lessons learned from previous sprints.
  • Improve team proficiency with GitLab and provide support as needed.
  • Ensure that issue details are readily accessible within individual tasks.
  • Distribute task assignments more evenly among team members.

Proposed Individual Improvements:

  • Communicate problems to teammates or the professor promptly for timely resolution.

APPRENTICESHIP PATTERN CHAPTER 1- 6 INTRODUCTION

Isaac stephen

            The apprenticeship patterns Guidance for the Aspiring Software craftsman is a book written by Dave Hoover and Adewale Oshineye. The introduction of this book helps us to focus. On the principles and fundamentals of becoming a better software developer, the authors emphasize to the continuous learning and mastering the craftmanship of being an effective software developer and think beyond entry level.
           

            Emptying Your Cup In this chapter I found it very interesting because at once I was in this stage as a beginner software developer, I would always have the mentality but reading this book showed me that I could always make new room for new knowledge and perspective by this means that it’s very important to be open to learn software developing in a different way.

            Walking the long road, I would relate this chapter to my life during the mastering of the software development journey it takes a long time and needs a lot of patience According the author they stated that” The pattern encourages aspiring software developers to recognize becoming proficient in the craft requires dedication.” Which is really coding being like learning a different language and takes time to master it. But walking the long road comes with embracing the journey and settling realistic exceptions.

            Accurate Self Assessments, in this chapter help me to understand that it is always important to evaluate one’s own skill in making yourself efficient as software developer. Always have honest evaluation on oneself, identifying gaps and seeking feedback.

Perpetual learning, in this chapter would show us the importance of self-growth as software developers that you should always embrace a growth mindset and always build learning habits.

Construct your curriculum. Is the means that a software developer you need to always create a personal curriculum to advance their skills and knowledge in the field such as identifying new learning goals, researching resources and creating a study plan

            Therefore, From the first chapter I have learned a lot that now I can in my day to day as a software developer for example seeking diverse perspective, embracing a growth mindset of continuous learning and improvement.

Libre food pantry

I was happy to work with the librefood pantry from Worcester state university because it gives me better picture on how I can work on Software problems and how to work as a team, At first was little bit confusing but after our first meeting I found it fun to work with but Also I read about the LIbreFoodPantry Main page about what is there mission, values, code of conduct, licensing , Acknowledgments and coordinating committee.

Additionally, exploring Thea’s pantry helped me to see how it was well organized the presentation of the valuable information how the user story can work this shows the step by step for the user interactions for example when the guest (student) visit the pantry information they can see when accessing the website

All in all the libreFoodPantry is a good website that helps or show user friendly interaction, Education and awareness

GRASP (General Responsibility Assignment Software Patterns)


GRASP (General Responsibility Assignment Software Patterns) is a design pattern in object-oriented software development used to assign tasks to different code modules.
GRASP provides a way to solve organizational problems and provides a common way to speak about abstract concepts. The design pattern sets responsibilities for objects and classes in object-oriented program design.
GRASP with an object-oriented design identifies its problems and solutions together as patterns.

Patterns of GRASP

Creator
• Who creates an Object? Or who should create a new instance of some class?
• Creator is a GRASP Pattern which helps to determine which class should be responsible for creating a new instance of a class

Information Expert
• Information Expert is a principle used to determine where to delegate responsibilities such as methods, computed fields, and so on.
• Expert principle says that assign those responsibilities to object for which object has the information to fulfill that responsibility.

Low Coupling
• Low coupling is an evaluation pattern that directs how to allocate responsibilities for the following benefits:

lower dependency between the classes,

change in one class having a lower impact on other classes,

Great ability to reuse.

Controller
• Deals with how to transfer request from the UI layer objects to domain layer objects.
• A controller object is a non-user interface object responsible for receiving or handling a system event.
• We can make an object as Controller, if

Object represents the overall system (facade controller)

Object represent a use case, handling a sequence of operations

High Cohesion
• High cohesion is an evaluation pattern that seeks to keep objects focused, manageable and understandable.
• High cohesion is generally used in support of low coupling.
• Benefits
– Easy to understand and maintain
– Code reuse
– Low coupling

Indirection
• Indirection pattern supports low coupling and reuses potential between two elements by assigning the mediation role between them to an intermediate object.
• Benefits: Low coupling, e.g. Facade, Adapter, Obserever.

Polymorphism
• According to the polymorphism principle, responsibility for defining the variation of behaviors according to the type is assigned to the type for which this variation happens.
• Benefits: Handling new variations will become easy.

Protected Variations
• Protected variations pattern protects elements against the diversity of other elements (objects, systems, sub-systems) by wrapping the focus of instability with an interface and using polymorphism to create a variety of implementations for this interface.
• Provides flexibility and protection from variations.

Pure Fabrication
• Pure fabrication is a class that does not represent concepts in the problem domain, specifically designed to achieve low coupling, high cohesion, and possible reuse arising (when the solution presented by the information expert pattern does not work).
• Benefits:
 High cohesion,
 low coupling
 And can reuse this class.

REFERENCE

  1. http://www.kamilgrzybek.com/design/grasp-explained/
  2. https://home.cs.colorado.edu/~kena/classes/5448/f12/presentation-materials/rao.pdf

Architectural patterns

Architectural Patterns.

These architecture patterns are a reusable solution to a commonly occurring problem within the field of software design. Software architecture patterns are a description or template for the structural organization or scheme for how to solve a problem that can be used in many different situations.

  1. Layered pattern

This pattern can be used to structure programs that can be divided into groups of subtasks, each of which is at a particular level of abstraction. Each layer provides services to the next higher layer.

Layers of a general information system:

  • Presentation layer 
  • Application layer 
  • Business logic layer
  • Data access layer 

Usage

  • General desktop applications.
  • E commerce web applications.

2. Client-server pattern

Consists of two parties; server and multiple clients. The server component will provide services to multiple client components. Clients request services from the server and the server provides relevant services to those clients.

Usage

  • Online applications such as email, document sharing and banking

4. Pipe-filter pattern

This can be used to structure systems which produce and process a stream of data. Each processing step is enclosed within a filter component. Data to be processed is passed through pipes.

Usage

  • Compilers. The consecutive filters perform lexical analysis, parsing, semantic analysis, and code generation.
  • Workflows in bioinformatics.

5. Broker pattern

It’s used to structure distributed systems with decoupled components. These components can interact with each other by remote service invocations.

Usage

6. Peer-to-peer pattern

In this pattern, individual components are known as peers. Peers may function both as a client, requesting services from other peers, and as a server, providing services to other peers.

Usage

7. Event-bus pattern

This pattern primarily deals with events and has 4 major components; event source, event listener, channel and event bus. Sources publish messages to particular channels on an event bus. Listeners subscribe to particular channels. Listeners are notified of messages that are published to a channel to which they have subscribed before.

Usage

  • Android development
  • Notification services

9. Blackboard pattern

This pattern is useful for problems for which no deterministic solution strategies are known. The blackboard pattern consists of 3 main components.

  • blackboard — a structured global memory containing objects from the solution space
  • knowledge source — specialized modules with their own representation
  • Control component — selects, configures and executes modules.

Usage

  • Speech recognition
  • Vehicle identification and tracking
  • Protein structure identification
  • Sonar signals interpretation.

10. Interpreter pattern

This pattern is used for designing a component that interprets programs written in a dedicated language. It mainly specifies how to evaluate lines of programs, known as sentences or expressions written in a particular language.

Usage

  • Database query languages such as SQL.
  • Languages used to describe communication protocols.

REFERENCE