Author Archives: Nguyen Vuong

BLOG 2 – Agile vs Scrum

There are many different methodologies that can be used for project management. The two that I would like the most are Agile methodology and Scrum methodology. So, what are the differences between these two methodologies, and when is choosing the right one? In this article, I want to summarize the key differences between agile and Scrum methodologies based on what I just read from Northeastern University Graduate Programs. Their article is really helpful for me and you to understand what they are and their differences. The article link is posted below. Feel free to check it out for further information: 

Agile vs. Scrum: What’s the Difference?

Agile vs. Scrum: What’s the Difference?

By Shayna Jouber

What is Agile Project Management? 

People say that Agile is a way of thinking about project management that focuses on delivering in small steps, being in touch with customers, and being able to adapt to change. Agile doesn’t tell you what process to use; instead, it gives you ideals and principles (like those in the Agile Manifesto) that you may use with other methods (like Scrum, Kanban, XP, etc.).\

Important traits: constant communication with customers and end users, willingness to change the scope of work, and delivering work in small steps.

What is Scrum Project Management?

One such approach in the Agile family is Scrum. It offers a clear procedure for handling tasks, including who completes them, how they are arranged, and when they are finished.

Typical Scrum responsibilities include a cross-functional team, a product owner who is in charge of optimizing the product’s value, and a scrum master who makes sure the team follows Scrum procedures.

Work is divided into sprints, which typically last two to four weeks. The team decides which subset of the scope to finish at a sprint planning meeting. Every sprint concludes with a review and retrospective to consider what was accomplished and make improvements.

Frequent delivery of “shippable” increments as opposed to waiting until the project is finished to provide everything is one of the clear benefits.

Agile vs Scrum – Key differences 

Agile is the underlying idea or strategy, and Scrum is a way to put Agile into practice.

Scrum is always Agile since it adheres to Agile principles, but utilizing Agile does not imply using Scrum; you may choose to use another Agile methodology instead.

Choosing the Right Methodology 

  • Agile: Agile makes sense if the project requires flexibility, frequent testing, stakeholder feedback, and shifting requirements.
  • Scrum: Scrum usually works well in situations with a lot of uncertainty, rapid changes, and the ability to arrange into sprint cycles.

Selecting the approach is only one aspect of it; another is having strong communication, leadership, critical thinking, project management, and organizational dynamics skills.

Conclusion 

Don’t use “Agile” and “Scrum” interchangeably; Agile is more comprehensive, and Scrum is one way to achieve it.

Before choosing Agile, consider the context of your project; if you decide on Agile, select the appropriate approach.

Methodology is only one aspect of successful project management; other factors include teamwork, stakeholder engagement, effective leadership, and flexibility.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Week 2-CS 343 blog: SOAP API

During class, I went over the topic of REST API and how amazing it was to understand and analyze how it works. However, there are many types of API, including REST API, GraphQL APIS, RPC APIS, and SOAP APIs. Today, I would like to go through what catches my attention the most is SOAP APIS. I read an article about explaining how SOAP API work, when to use them, and how they compare with modern REST APIS, and I would love to share it with you. The article is posted below, and feel free to check it out for further information (all the information is according to the article) 

https://blog.postman.com/soap-api-definition/

WHAT is SOAP? 

In the late 1900s, SOAP, a messaging protocol that was developed to enable different systems running on multiple operating systems, languages, and networks, with the purpose is to exchanging structured information reliably 

Unlike REST, SOAP focuses on messages rather than resources. 

SOAP messages are formatted in XML and usually contain: 

  • Envelope – defines the start and end of the message 
  • Header – contains optional information like authentication or transaction details 
  • Body – holds the actual request or response data 
  • Fault – handles errors 

How SOAP works?  

A SOAP client sends an XML request to a server, which also responds with another XML message. These communications often occur over HTTP (but sometimes also SMTP, TCP, or UDP) 

  • SOAP messages are defined by the Web Services Description Language (WSDL) to describe the operations, parameters, and return types

Advantages of SOAP

  • Platform independent – works across languages and OS. 
  • Protocol flexible – not limited to HTTPS 
  • Strong security – supports encryption and authentication 
  • Error handling – display clear fault messages 
  • The ideal workplace, where rigid relationships and dependability are essential 

Disadvantages of SOAP 

  • More complex and verbose than REST 
  • Harder to evolve or version 
  • Slower performance due to XML analysis 
  • It is less appropriate for web applications because of its limited catching support. 

Common Use Cases 

SOAP API is commonly used in banking, telecommunications, transportation, and enterprise systems – these cases require reliability, structured data, and strict security. 

  • Examples: 

In banking, SOAP API is used for bank transfers.

In transportation, flight booking systems 

ETC, ….

Shipping and logistics services 

Conclusion 

SOAP API is a great protocol, robust and standardized, but compared to REST, it’s less flexible. REST is better for modern web applications and faster iteration. SOAP API is always needed and valuable for many applications that prioritize security, reliability, and formal structure.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Week 1 CS-343 Blog: Strategy Pattern

I want to introduce a powerful tool in the arsenal of software engineers aiming to write clean, flexible, and maintainable code. The tool that most developers would need to upgrade the code without modifying the existing client code , and it is particularly helpful in scenarios involving algorithms of your code. The tool is called “Strategy Pattern“.

What is Strategy Pattern?

Strategy Pattern is a behavioral pattern that enables the selection of algorithms at runtime. This tool is crucial for developing flexible, maintainable, and modular code. Especially when multiple algorithms are applied to solve a problem. The key goal is to allow software entites be open for extension but closed for modification, meaning without having any impact or changed on the client code, but modifying and extending it.

Type of Strategy Pattern

  1. Context – Holds a reference to a Strategy, delgates work to it. The Context doesn’t implent algorithm logic itself.
  2. Strategy Interface – Defines a common method (or set of methods) that all strategies must implement, so they’re interchangeable.
  3. Concrete Strategies: Classes implementing the Strategy interface, each providing a different algorithm implementation.

Benefits

  1. Flexibility – New strategies can be added without modifying existing code.
  2. Seperation of Concerns – Context is freed from algorithm details; each strategy handles its own logic
  3. Easy to test: You can test each strategy class independently.

Disadvantage scenario

  • Using pattern strategy creates more classes to manage, which can complicate desgin
  • Some abstraction layers which may or may not be worth it in simpler scenarios.

Conclusion

The startegy patterns is useful when you have multiple algorithms or behaviors that needs to be added or swaped dynamically, in order to solve problem without impacting the existing code. It helps you build modular, maintainable, and extensible systems. But you should be mindful about the extra complexity it comes with.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Blog 1 – How to manage and improve software processing.

Improving your software processing is crucial, especially when working on a group project, managing time pressure, and leading a team, among other responsibilities. Here is a great resource that I found invaluable for beginners and interns. “https://axify.io/blog/software-process-improvement“

According to Pierre Gilbert, a software delivery expert, he highlighted the “7 steps” to implement software process improvement, or SPI. I will break down those steps to get a better understanding.

Step 1: Make the problem visible – Use historical data to show where delays, defects, process inefficiencies are happening

Step 2: Get the Team’s Buy in – Don’t just impose changes. Use data to show why improvements are needed so your team member see the value.

Step 3: Track essential metrics – Use DORA metrics + value stream mapping to find bottlenecks

However, this step still gets me confusing, so feel free to checkout the link to have a better understanding.

Step 4: See where improvements would be most effective – Prioritize high-impact areas rather than trying to change everything at once.

Step 5: Make a plan – Clear responsibilities; tools; define which existing processes are targeted; pilot projects before roll-out; ensure feedback loops.

Step 6: Implement the plan – Execute carefully; monitor; allow for adjustment; don’t force changes that slow things down without justification; use continuous feedback.

Step 7: Adjust as needed – SPI is never “done” – measure progress via KPIs, adapt if cultural or resource issues arise, keep refining.

After reading those steps, I can’t imagine the environment of software engineering is not as simple as I thought. Understanding the steps could help me preparing of what’s coming next.

Before improving SPI, we need to understand the common challenges people usually face when it comes to working on project.

Time pressure – in high-pressure environments, it’s easy to prioritize delivery over process improvement.

Poor management or lack of ownership – improvements can be fragmented without clear responsibility

Team maturity – less mature teams may struggle with discipline & consistent adoption.

Overall, reading this could help you get ahead of what’s upcoming in the software engineering environment. For further information, check out the link above.

#CS-348, #SPI

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Introduction to CS-348 Blog!

To all of the CS-348 students, welcome to my CS-348 blog!

This is where I will write about some new techniques that you may or may not be familiar with in computer science, particularly software management. From here, we can all learn together and share our knowledge, which can improve our programming skills throughout the semester.

A little bit about myself, my name is Nguyen Vuong. I’m a senior Computer Science major at Worcester State University. As a senior, I’m happy to share my knowledge and skills in the hope that it could help you get through the years more easily.

I also make mistakes a lot, and love to learn new things. So, feel free to share what you have, and we will all study it together! Let’s all look forward to a great year!

Nguyen Vuong

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Introduction to CS-343 blog

To all of the CS-343 students, welcome to my CS-343 blog!

This is where I will write about some new techniques that you may or may not be familiar with in computer science, particularly software construction and architecture. From here, we can all learn together and share our knowledge, which can improve our programming skills throughout the semester.

A little bit about myself, my name is Nguyen Vuong. I’m a senior Computer Science major at Worcester State University. As a senior, I’m happy to share my knowledge and skills in the hope that it could help you get through the years more easily.

I also make mistakes a lot, and love to learn new things. So, feel free to share what you have, and we will all study it together! Let’s all look forward to a great year!

Nguyen Vuong

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Week 13: Re-evaluating the ‘Double D’s’ of Software Development: Test Driven Development

Jeremy D. Miller’s blog post, “Re-evaluating the ‘Double D’s’ of Software Development: Test Driven Development,” offers a thoughtful exploration of Test Driven Development (TDD) and its role in modern software engineering. Drawing from his experiences at Calavista and in open-source projects, Miller revisits TDD’s principles, benefits, and challenges, providing valuable insights for developers and teams considering or currently practicing TDD. Feel free to check out his blog at https://jeremydmiller.com/2021/01/21/re-evaluating-the-double-ds-of-software-development-test-driven-development/

Understanding Test Driven Development (TDD)

TDD is a development methodology where developers write automated tests before writing the actual code. These tests define the desired functionality, guiding the subsequent code implementation to ensure it meets the specified requirements. Originating from the Extreme Programming (XP) movement in the late 1990s and early 2000s, TDD emphasizes rapid feedback and iterative development.

Miller highlights that, despite its name, TDD is more accurately a software design technique than a testing strategy. By writing tests first, developers are compelled to consider the code’s design and desired outcomes upfront, leading to more intentional and maintainable code structures.

The Value of TDD: Feedback, Design, and Refactoring

One of TDD’s core strengths is its provision of immediate feedback. As developers alternate between writing tests and code, they receive constant validation of their work, facilitating quicker identification and resolution of issues. This rapid feedback loop not only accelerates development but also enhances code reliability.​

Moreover, TDD encourages modularity. Since writing tests for tightly coupled code is challenging, developers are motivated to design more modular and decoupled components, improving overall code maintainability. Miller points out that TDD acts as a “forcing function,” prompting developers to think critically about code structure and dependencies from the outset

Implementing TDD in Practice

At Calavista, TDD is a standard practice in client engagements and internal projects. Miller advocates for its adoption, citing its benefits in producing high-quality, maintainable code. He encourages teams to view TDD not as a rigid doctrine but as a flexible approach that can be tailored to fit various project needs and contexts.

For developers new to TDD, Miller suggests starting with small, manageable components and gradually incorporating testing into the development workflow. Over time, this practice can lead to a more disciplined and thoughtful coding approach

Conclusion

Jeremy D. Miller’s reevaluation of TDD offers a nuanced perspective on its role in software development. By framing TDD as a design methodology that promotes feedback, modularity, and continuous improvement, he provides a compelling case for its adoption. While acknowledging its challenges, Miller’s insights underscore the potential of TDD to enhance code quality and developer productivity when applied judiciously.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Week 12: ​Understanding the Importance of Software Testing: A Comprehensive Guide

In the dynamic world of software development, ensuring the reliability and functionality of applications is paramount. Software testing emerges as a critical process that verifies whether a software product meets its intended requirements and functions seamlessly under various conditions. It’s not merely about identifying bugs; it’s about validating that the software delivers a quality experience to its users.

Types of Software Testing

Software testing encompasses various methodologies, each targeting specific aspects of the application:​

  1. Functional Testing: Validates that each function of the software operates in conformance with the requirement specifications.​Full Scale
  2. Non-functional Testing: Assesses non-functional aspects like performance, usability, and reliability.​Full Scale+1Full Scale+1
  3. Regression Testing: Ensures that new code changes do not adversely affect the existing functionalities of the product.​
  4. Black Box Testing: Examines the functionality of an application without peering into its internal structures or workings.​
  5. White Box Testing: Involves testing internal structures or workings of an application, as opposed to its functionality.​
  6. Automated Testing: Utilizes specialized tools to execute tests automatically, increasing efficiency and coverage.​
  7. Manual Testing: Involves human testers executing test cases without the use of automation tools.​

Levels of Software Testing

Testing is conducted at various stages of the software development lifecycle:​

  1. Unit Testing: Focuses on individual components or pieces of code for a system.​
  2. Integration Testing: Examines the interactions between integrated units/modules.​
  3. System Testing: Tests the complete and integrated software to evaluate the system’s compliance with its specified requirements.​Full Scale+1Full
  4. Acceptance Testing: Determines whether the system satisfies the business requirements and is ready for deployment.​

The Role of Software Testers

Software testers play a pivotal role in the development process. They are responsible for designing test cases, executing tests, and identifying bugs before the software reaches the end-user. Their work ensures that the final product is reliable, efficient, and user-friendly.

Conclusion

Software testing is an indispensable part of the software development process. It ensures that the final product is of high quality, meets user expectations, and functions as intended. By understanding and implementing effective testing strategies, organizations can deliver robust and reliable software products.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Week 11: 10 Reasons Why Writing Tests Will Make You a Better Developer

Writing tests might seem like extra work, but it’s one of the most impactful habits you can develop as a programmer. Beyond catching bugs, tests improve your design, boost your confidence, and save time in the long run. Drawing from the insights shared in the NDepend Blog, here are ten compelling reasons to embrace testing in your development workflow.​

1. Spot Ambiguities Early

Writing tests forces you to consider edge cases and potential pitfalls, such as null references or uninitialized data. By thinking from the user’s perspective, you can identify and address ambiguities in requirements early on, leading to more robust code.​

2. Write Better Code from the Start

Testing encourages you to question your assumptions and validate your logic. This practice helps you recognize that initial implementations may have flaws, leading to more thoughtful and accurate coding.​

3. Achieve Better Design

Tests naturally lead to decoupled and modular code. By abstracting complex infrastructures behind interfaces, you create code that’s easier to test and maintain, aligning with principles of good software design.​

4. Simplify Debugging

Instead of navigating through the entire application to reach a specific context, tests allow you to isolate and verify individual components. This targeted approach makes debugging more efficient and less time-consuming.​

5. Maintain Up-to-Date Documentation

Tests serve as living documentation, illustrating how different parts of your codebase are intended to function. They provide clear examples of usage and expected behavior, which is invaluable for future reference and onboarding new team members.​

6. Measure Progress Accurately

With a comprehensive test suite, you can track your development progress more precisely. Passing tests indicate completed functionality, while failing tests highlight areas that need attention, providing a clear roadmap for development.​

7. Catch Regressions Early

Automated tests run consistently, alerting you to unintended changes that may break existing functionality. This early detection helps maintain the integrity of your codebase as it evolves.​

8. Refactor with Confidence

A robust test suite gives you the assurance to refactor code without fear of introducing new bugs. Knowing that tests will catch any regressions allows you to improve code quality safely.​

9. Release with Confidence

Before deploying new features or updates, running your tests ensures that everything works as expected. This verification process reduces the risk of releasing faulty code, leading to more stable and reliable software.​

10. Save Time and Enjoy Development

While writing tests requires an initial investment of time, it pays off by reducing the time spent on debugging and maintenance. Moreover, the confidence and clarity that tests provide make the development process more enjoyable and less stressful.

Embracing testing is not just about preventing bugs; it’s about fostering a mindset that values quality, clarity, and continuous improvement. By integrating testing into your workflow, you set yourself up for success and growth as a developer

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.

Week 9: Software Testing vs. Quality Assurance: Understanding the Difference

In software development, Software Testing and Quality Assurance (QA) are two essential practices, but they serve different purposes. While both aim to ensure the delivery of high-quality software, understanding their differences is key to a successful development process.

What is Software Testing?

Software Testing involves evaluating a software application to find bugs, defects, or issues. The goal is to verify that the software functions as expected, meeting the specified requirements. Testing usually takes place after the software is developed, and it includes various types such as unit, integration, and system testing. The primary purpose of testing is to identify errors before releasing the product.

What is Quality Assurance?

Quality Assurance (QA) is a broader, more proactive approach. It focuses on improving the entire software development process to prevent defects before they happen. QA involves setting up best practices, frameworks, and guidelines to ensure that all stages of development—planning, coding, testing—follow high standards. QA runs throughout the software lifecycle, not just after development, and aims to ensure continuous quality improvement.

Key Differences Between Software Testing and Quality Assurance

  1. Scope:
    • Software Testing focuses on identifying defects in the finished product.
    • QA aims to prevent defects by improving the development process.
  2. Objective:
    • Software Testing’s goal is to find issues in the product.
    • QA’s goal is to enhance the development process and ensure quality from start to finish.
  3. Timing:
    • Software Testing typically happens after development.
    • QA is an ongoing process that begins early in development and continues throughout.
  4. Approach:
    • Software Testing is reactive, identifying issues after they arise.
    • QA is proactive, aiming to prevent issues before they occur.

Conclusion

While Software Testing focuses on finding defects in the product, Quality Assurance works on improving processes to avoid defects in the first place. Both are critical in ensuring that the final product is reliable and meets user expectations. By integrating both, development teams can produce high-quality software more effectively.

From the blog CS@Worcester – Nguyen Technique by Nguyen Vuong and used with permission of the author. All other rights reserved by the author.