Write a 2 page reading response on chapters 3, 4 and 9. You must locate three quotes to which you wish to respond. For each quote, you should restate the quote along with a citation and then respond critically to the quote. Each selected quote should be from a different chapter of the assigned reading. Choose quotes that are meaningful to you, that you have experienced personally or about which you have a strong opinion. Make a claim about the quote, agree with it or disagree with it, and justify your claims. These responses should show your ability to think critically about the material and should also prepare you to discuss your opinions in class. You will be evaluated on the quality and coherence of your claims and your ability to justify them.   # and here is an example report for reference. The report should match

# Abide by the following Rubric
Reading Response Rubric
Quality/Score	Quotations	Claim	Support
Excellent	A clear, explicit quotation is present with a reference to the chapter and section in Pragmatic Programmer.	A clear claim of agreement, disagreement, or a more nuanced opinion with regards to the validity or necessity of the quotation is present.	The claim is clearly justified through well reasoned supporting evidence and/or logic. The response shows evidence of critical thinking.
Good	A clear quotation is present with a reference to the chapter but not the section number.	The response discusses the quote in a fashion that expresses an overall opinion, but the opinion is not clearly stated.	Supporting arguments are given, but there may not be a clear and explicit connection between the arguments and precisely how they support the claim.
Tolerable	An idea from the text is paraphrased with a reference to the chapter from which it came.	-	Supporting arguments nebulously agree with the claim but are vague, wishy washy, or otherwise deliberately unclear.
Poor	It is unclear whether an idea was taken from the text or from where in the text it was taken.	The response takes no stand with respect to the given quote.	Supporting arguments for the claim are absent, tangential to the claim itself, or try only to further describe the quotation.  instructions are as follows: , you are required to submit a critical response to the reading. These responses should focus your thoughts and show that you have meaningfully reflected on the reading and how it connects with your own experiences.

# This is an example of a past reading response. This is what the a quote should look like

In The Pragmatic Programmer, the authors emphasize several key practices that are essential for becoming a more effective developer. From taking personal responsibility in team settings, to avoiding code duplication, and exploring the benefits of pair programming, the book offers practical advice that can transform the way we approach software development. The authors use relatable examples to illustrate how these concepts help programmers not only write better code but also improve collaboration and problem-solving skills. Through my own experiences, I have seen how applying these ideas can make coding projects more efficient and maintainable.

One of the most impactful quotes from section [XXXXX] the first chapter is, "Responsibility is something you actively agree to. You make a commitment to ensure that something is done right, but you don’t necessarily have direct control over every aspect of it"​(Thomas & Hunt, 2019, p. 3). This idea is fundamental to being a pragmatic programmer. It resonates with my experience during an introductory software engineering class, where I was part of a team working on a group project. A few team members hesitated to contribute to the codebase and would often blame unclear requirements or time constraints when issues arose. This behaviour perfectly illustrates the "cat ate my source code" mentality described in the book, where individuals fail to take responsibility for their work.

In contrast, I believe that as developers, we must handle the tasks we commit to, regardless of obstacles. Even when things don’t go as planned, such as when unexpected bugs or delays happen, it is still our job to face the problem head-on rather than deflect blame. By accepting responsibility and offering solutions, we maintain trust within our teams, ensuring progress despite setbacks. This lesson from the book directly reflects my belief that professionally handling responsibilities is crucial for both personal growth and team success.

Another principle from the book is from Chapter 2, The principle of "Don't Repeat Yourself" (DRY) is central to pragmatic programming. As the authors state, "DRY is about the duplication of knowledge, of intent. It’s about expressing the same thing in two different places, possibly in two totally different ways"(Thomas & Hunt, 2019, p. 31). Initially, I found the acronym quite silly and did not truly appreciate its significance. However, over time, I realized that this principle is one of the most fundamental concepts in software development. Duplication in code often leads to unnecessary complexity and makes maintenance much harder, especially when knowledge is replicated in various parts of a system.

In my object-oriented programming class, I experienced firsthand how adhering to DRY can improve both the quality and manageability of a project. During a Java project, I spent additional time refactoring the code into reusable methods. The result was a more structured and easier-to-maintain codebase. Whenever errors appeared, I could quickly isolate the issue to a specific method rather than sifting through redundant code. This made debugging more straightforward and demonstrated how crucial it is to avoid duplication. Following DRY made the entire development process smoother, reinforcing the value of this practice.

At first, I thought pair programming seemed counterproductive. I questioned how having two people working together on one task could be more efficient than each developer coding separately. However, as stated in The Pragmatic Programmer, "Fiddling around with typing esoteric words and symbols that the compiler will grudgingly accept takes a fair bit of our own processing power" (Thomas & Hunt, 2019, p. 257). This reflects the challenge of balancing low-level tasks, such as coding syntax, with higher-level considerations like design and problem-solving. The human brain struggles to manage both simultaneously, which is why having a second person focused on high-level thinking can significantly boost productivity.

While I haven't fully explored pair programming, I unintentionally experienced its benefits while working on an Android app with a classmate. During a moment of complexity, I stepped back from my laptop to verbally sort through my thoughts. As I spoke, my partner typed small code snippets to capture ideas. This collaboration allowed me to focus on the direction of the project while my partner handled the coding. This experience helped me appreciate the power of pair programming, as it aligns with how humans naturally collaborate—one person handles the details while the other navigates the broader issues.

In conclusion, The Pragmatic Programmer presents several valuable concepts that have shaped my understanding of software development. The idea of taking responsibility for one's work, as highlighted in Chapter 1, is important for maintaining trust and ensuring the team’s success. My experience in software engineering taught me the importance of owning my tasks and avoiding the blame game. Chapter 2 introduces DRY, a fundamental principle that helps eliminate code duplication. Applying this during my Java project made debugging easier and improved the overall structure of the codebase. Lastly, Chapter 8’s discussion on pair programming offered a new perspective on collaboration. My experience working on an Android app revealed the benefits of having one person focus on code while the other handles broader planning, which mirrored the effectiveness of pair programming. These lessons demonstrate how the book's insights are both practical and applicable in real-world scenarios, and are lessons I plan to carry with me for the future.