In our modern world, the journey to mastery is often overlooked in the software development field. Traditional notions of career advancement can cloud our vision as aspiring programmers, leading us away from the path of true craftsmanship. The Long Road pattern is a reflection on our journey of becoming masters in the field and emphasizes the importance of lifelong learning and growth. 

Reflecting on The Long Road pattern, I found myself in agreement with its core message, while also grappling with the implications it holds for my own career path. The pattern’s emphasis on mastery as a lifelong journey stood out to me, serving as a reminder of the importance of patience and persistence in the pursuit of excellence and success. 

The pattern also presents an analogy to martial artists attempting to receive the black belt and connecting it to software development. This highlighted the discipline, patience, and perseverance required to master any craft. Additionally, we should embrace our path, rather than just fixating on the destination. This reminded me that we should appreciate the process of learning and growth, rather than being solely focused on achieving immediate success. 

The Long Road has challenged me to essentially reassess my approach in the field. Instead of chasing after quick promotions or higher paying positions, I now see value in prioritizing long-term growth and development, and measuring progress based on understanding and my quality of work. Therefore, encouraging me to adopt a more patient and deliberate approach to my career, knowing that mastery is a process that’ll unfold over time. 

While I agree with the message expressed in the pattern, I couldn’t help but wrestle its implications with our rapidly changing industry. Today, new languages, methodologies, and frameworks evolve and emerge by the daily. The notion of dedicating a lifetime to master a single craft could seem unreasonable. While I value the importance of patience in honing my skills, I believe there is merit in adaptability and versatility. As developers, we must remain agile and responsive to change, continuously evolving our skill set to meet the demands of the evolving industry. Therefore, while I understand the message, I believe it’s equally important to embrace flexibility in our journey. 

This pattern has left a mark on my perspective as an aspiring craftsman. It has challenged me to embrace this journey of mastery with patience and perseverance, even when faced with uncertainty. As I continue to grow and walk down this path, I am committed to the principles of lifelong learning and growth, knowing that eventually reaching true mastery is a destination worth striving for. 

From the blog CS@Worcester – Conner Moniz Blog by connermoniz1 and used with permission of the author. All other rights reserved by the author.

Reviewing your code is important, it makes sure that the code is correct and functions the way you want it to. Code review helps cover so many areas of your code. You want to make sure that your code is understandable for anybody else who looks at it and that it’s clear, by reviewing your code you can go back and fix anything that could be making your code more complicated. Code reviewing is important when working with a team, your team should understand what your code is trying to execute without being confused. When it comes to coding so much of your work can change throughout the process which is normal but with so many changes happening it can get confusing. Code reviewing comes with so many different solutions when it comes to writing code it nitpicks what parts are important or not. It’s a helpful tool that helps coders make sure they have clean code and that when working with a team everyone’s comments are heard and changes are made.

Code reviews can be tough if the team isn’t together so questions and comments can’t be answered. Another thing is that the code could be overlapping, and missing a team meeting could affect the code and confuse team members about what they should be writing ending up in similar code. If that happens the next person reviewing the code will find duplicate code and will end up pushing the team’s work behind. Making sure your team communicates will help prevent more code from having to be fixed and reviewed even though you don’t want to add more work on top of what you already have. Code review makes sure your work is good quality and organized. Having sloppy issues and mistakes doesn’t look good for you, your team, and your job. Code review is about making sure your work is organized and clean, you want to make sure you put out good work without having a lot of issues. Especially as a team you want to meet those standards and follow them. Always make sure to review your code because there could be small errors or even confusing comments that will make your code more complicated than it needs to be.

https://blog.pragmaticengineer.com/good-code-reviews-better-code-reviews/

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.

For this week’s blog post, I chose the article “Code Review Best Practices – Lessons from the Trenches” by Drazen Zaric. I chose this article because its topic fits perfectly with the cove review segment in the syllabus. This article discusses why you should do code reviews, how code reviews act as quality assurance, how code reviews function as a team improvement tool, how to prepare a pull request for preview, and, of course, how to review code. In this article, I will be discussing why you should do code reviews and how they work as quality assurance.

Reviewing code is one of the most essential parts of the development process. “It should be obvious that the primary purpose of code review is to assess the quality of the changes being introduced. I mean, the dictionary definition of review says precisely that ‘review (noun) – a formal assessment of something with the intention of instituting change if necessary.’ Of course, code being code, there’s a lot of things that can be checked and tested automatically, so there’s nuance to what needs to be checked in an actual code review.” As mentioned in the article, there are many things that can be tested and should be tested. This leads to a need for many people to review your code, and you will need to review many other people’s code to make sure the best possible software is being developed. Quality assurance must be done well as a significant part of making sure your software is the best it can be.

In this section of the blog post, I will discuss how the article mentions how code review is incredibly useful in quality assurance. “There are many ways in which code reviews help maintain the quality bar for the codebase and the product. In the end, it comes down to catching mistakes at a level that can hardly be automatically tested, such as architectural inconsistencies. Also, the code for automated tests should be reviewed, so there’s a meta-level at which reviews help with QA.” As mentioned, code review’s main boon to quality assurance is finding issues that can’t, or often need to be caught, through traditional testing methods, like automated testing. The article also mentions using checklists for storing what needs to be checked and how and what the results of said checks should be. “You can have your own checklist or make it a shared list for the team or a project. There’s a ton of material written on the usefulness of checklists. In Getting Things Done, David Allen puts forward a simple idea – our minds are great at processing information but terrible at storing and recalling it. That’s why checklists are a great way of externally storing and breaking down a planned or repetitive task.” Having a method of keeping track of what is done, what needs to be done, and what is incomplete is essential in working on any large project, let alone on a software development project.

From the blog CS@Worcester – P. McManus Worcester State CS Blog by patrickmcmanus1 and used with permission of the author. All other rights reserved by the author.

The blog post highlights the qualities as well as the differences between these two types of testing, static testing and dynamic testing. I chose this blog post because as this course covers software quality assurance and testing as well as the fact that we have spent time in class covering these two types of testing I believe that this blog post is able to highlight and reinforce core concepts that will be able to assist in gaining further knowledge withing this class. In addition, the blog post is able to explain the information regarding static and dynamic testing in a simple and easy to understand format that further compliments the idea of using this blog post as a resource to reinforce these topics.

The blog post as previously discussed covers static testing vs dynamic testing. We learn that static testing involves testing the code without actually running it while dynamic testing involves running the code to test it’s outcomes through various testing circumstances. From those two descriptions we can tell how static testing relies on testing through software documentation as well as the design of the code itself. However, dynamic testing is able to execute the program allowing the testers to test how the code will work in an assortment of testing scenarios. This concept allows testers to see how the code will work once it is released to the public to verify that it works as intended. These two types of testing are very different in their methods of achieving a successful test. Static testings wants to identify problems and improve on them early in development while dynamic testing wants to validate the performance and functionality of the code once it is in a executable state. Since they have different intents your requirements for the project is what determines what testing you will choose.

From what I have learned from the blog post I believe it was very helpful and was able to reinforce core concepts that will help me further in this class. I believe learning more about static and dynamic testing will help me when it comes to working in this class as well as assist in knowing how to test in a professional setting. Knowing the core differences between the two will allow me to know what type of testing will be best for certain circumstances when it comes to projects. In conclusion, this blog post was very helpful and will be utilized in the future.

https://testsigma.com/blog/static-testing-and-dynamic-testing

From the blog CS@Worcester – Giovanni Casiano – Software Development by Giovanni Casiano and used with permission of the author. All other rights reserved by the author.

A Critical Component of Software Quality Assurance

I was based to this blog: https://www.celestialsys.com/blogs/software-testing-boundary-value-analysis-equivalence-partitioning

From the blog CS@Worcester – Coding by asejdi and used with permission of the author. All other rights reserved by the author.

Summary of the Pattern: The “Concrete Skills” pattern emphasizes the importance of acquiring skills that can be directly applied in a professional setting, particularly for individuals in the early stages of their career in technology. It advocates for the development of a portfolio of practical, demonstrable skills that make one a valuable team member from day one. These skills not only facilitate smoother transitions into new roles or projects but also enhance an individual’s employability and credibility within their field.

My Reaction: The straightforwardness of the “Concrete Skills” pattern immediately resonated with me. It serves as a pragmatic reminder that, amidst the allure of high-level theories and complex conceptual frameworks, the ability to contribute tangibly and effectively to a project is invaluable. This pattern has reinforced my belief in the necessity of balancing theoretical knowledge with practical skills that can be immediately applied to solve real-world problems.

Insights and Changes in Perspective: Delving into this pattern prompted me to reassess my skill set and identify areas where my capabilities could be seen as both concrete and valuable in a team setting. It has shifted my focus towards a more balanced approach to learning, where equal weight is given to both the acquisition of theoretical knowledge and the development of practical, hands-on skills. This realization has not only influenced the way I plan my learning goals but has also altered how I present myself professionally, emphasizing skills that can have an immediate impact.

Disagreements and Critiques: One potential critique of the “Concrete Skills” pattern might be its perceived emphasis on the immediate applicability of skills, which could inadvertently sideline the long-term benefits of foundational, theoretical knowledge. However, I believe the pattern does not dismiss the value of theory but rather highlights the importance of having a well-rounded skill set. It’s about striking the right balance between being able to contribute now and laying the groundwork for future innovations.

Conclusion: The “Concrete Skills” pattern has profoundly influenced my approach to professional development, highlighting the importance of building a repertoire of skills that are as tangible as they are valuable. It serves as a guide for navigating the complex landscape of technology careers, where the ability to demonstrate concrete skills can set one apart in a competitive field. As I continue to advance in my career, I am motivated to cultivate a diverse set of skills that not only underscore my theoretical knowledge but also showcase my capacity to contribute meaningfully to any team or project.

From the blog CS@Worcester – Abe's Programming Blog by Abraham Passmore and used with permission of the author. All other rights reserved by the author.

having taken a look at Kanban (which was part of our homework task), a powerful framework for software development teams, has become a cornerstone for teams aiming to enhance efficiency and transparency in their workflow. Originating over 50 years ago from Toyota’s manufacturing processes, the methodology has seamlessly transitioned into the realm of software development. In this blog post, we’ll delve into the key principles of Kanban, its historical roots, and its application in modern agile practices.

from what information i was able to gather, Kanban is grounded in the just-in-time (JIT) manufacturing process that Toyota pioneered in the late 1940s. it draws inspiration from supermarkets stocking products based on consumer demand, to which Toyota aimed to align their factory inventory levels with actual material consumption. The implementation involved passing a visual signal, known as a “kanban,” between teams to communicate real-time capacity on the factory floor and with suppliers.

Fast forward to today, and agile software development teams have embraced these JIT principles to optimize work in progress (WIP) and match it with the team’s capacity. The heart of Kanban lies in visualizing work, limiting WIP, and ensuring real-time communication of capacity.

Central to the Kanban methodology is the Kanban board, a visual project management tool available in physical or digital form. This tool aids in visualizing work, limiting work-in-progress, and maximizing efficiency or flow. Whether physical or virtual, the Kanban board serves as the single source of truth for the team’s work, ensuring transparency and real-time communication of capacity.

Kanban offers a plethora of advantages for software developing teams, making it one of the most popular software development methodologies today. The flexibility in planning, shortened time cycles, fewer bottlenecks, and the use of visual metrics contribute to its widespread adoption. The ability to adjust priorities without disrupting the team, optimize cycle time, and limit WIP ensures that Kanban is not only effective but also adaptable to different team structures and objectives.

in terms of what stuck with me the most after reading the article, i’d say the historical connection to Toyota’s manufacturing processes highlighted the enduring nature of concepts like just-in-time manufacturing and efficient inventory management. Understanding how these principles seamlessly translated into the realm of software development underscored the universal applicability of Kanban aswell as the emphasis on visualization through Kanban boards and the use of cards for each work item struck me as a simple yet powerful way to enhance collaboration and transparency within a team. The flexibility in planning, especially the ability to reprioritize work without disrupting the ongoing tasks, stood out as a valuable feature. This aligns well with the dynamic nature of software development, where changes in priorities are not uncommon.

https://www.atlassian.com/agile/kanban

From the blog CS@Worcester – CSTips by Jamaal Gedeon and used with permission of the author. All other rights reserved by the author.

Refactoring is the process of restructuring a code without changing or adding to its functionality and external behavior. There are a lot of ways to go about refactoring but it mostly goes towards applying standard basic actions. These changes in the existing code save the software’s functionality and behavior since the changes are so tiny, they are less likely to cause any errors. So, what is the point of refactoring? Well, refactoring is to turn any messy confusing code into a clean understandable one instead. When a code is messy it means that the code is hard to understand and maintain, when it’s time to add a required functionality it causes a lot of problems with the code because it’s confusing already. With a clean code, it’s easier to make any changes and improve on any problems. Also with a clean code anybody who ever works with the code is able to understand the code and can appreciate how organized it is. When a messy code isn’t cleaned up it can affect any feature developments because developers have to take more time to understand the code and track the code so that they can make any changes themselves.

Knowing when to refactor is important and there are different times to refactor your code. Like refactoring, while you’re reviewing the code, reviewing the code before it goes live is the best time to refactor and make any changes you can before pushing it through. You can also schedule certain parts of your day to refactor your code instead of doing it all at once. By cleaning your code you are able to catch any bugs before they create any problems in your code. The main thing about refactoring your code is that cleaning up a dirty code can reduce technical debt. Clean code is easier to read and if anybody else besides the developer works on that code they are also able to easily understand that code as well as maintain and add features to it. The less complicated the code is, it can lead to improved source-code maintenance. With a clean code, the design can be used as a tool for any other developers it can become the basis of a code elsewhere. This is why I believe that refactoring is important because changing just the smallest piece of code can lead to a better functional approach to programming. It helps developers get a better understanding of the code as well as making better design decisions.

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.

REST stands for Representational State Transfer. This means that when a client requests a resource using a REST API, the server transfers back the current state of the resource in a standardized representation.

From the blog CS@Worcester – Andres Ovalles by ergonutt and used with permission of the author. All other rights reserved by the author.