Hello, My name is Aksh Patel, and this is my introduction blog. I am a senior year Worcester State University student. My major is Computer Science and i am more interested Design Technique.
I will take CS-343 class to learn about more in my interesting stuff.
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.
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.
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.
September 8th, 2025
Hello! This is a blog? Probably. As a current student, I will (hopefully) be blogging about my experiences in Computer Science. Otherwise, I don’t really know what to do with this. Anyhow:
I currently have some experience with code. I took AP Computer Science in high school, and a Game Design Class (technically twice by two different teachers due to a mix-up in my high school schedule, but frankly, they did different things so I don’t actually regret it.)
This gives me experience with both Python and Java, although at a beginner level. Additionally, my First Year Seminar class refreshed me on Python, and I took the beginner Unix Systems Programming, which taught me a little bit of C.
I did use Scratch to make a game back in high school but I was atrocious at it. I remember having a habit of over complicating my stuff too. Especially in my Game Design Class. I took AP Computer Science the same year as it and because all the other students were seniors, my teacher let me work on my Game Design stuff after the seniors graduated. I took twice as long as everyone else and barely finished my “game.” (Officially, I never finished it and passed in a partially modified older project.) I am near certain the teacher just let it slide because I was working despite having no official assignments in AP Computer Science and helping people in my game design class. (I have like, 2 unfinished projects? Both were intended to be my final program for my Game Design Class, but neither were passed in.)
The reason I decided to pursue Computer Science was pretty simple: I thought video games were cool. Then I just went for it, and it was okay. I had some classes in high school but nothing complicated. But as time went on, I eventually went into my AP Computer Science class which I did okay in. One day, the teacher said I “have a passion” for Computer Science. Frankly, I thought that was a weird statement since I didn’t really do that much coding nor was I particularly good at it, but it made me feel good about myself so here I am. (Nowadays I hear of my cousins swapping Majors from Computer Science to basically anything else so I’m either doing okay or making a grave mistake. Oh well.)
Anyhow, that’s my current experience with Computer Science and I guess I’ll give you all an update later on.
Thanks for Reading,
Ryan Nguyen
From the blog CS@Worcester – Ryan's Blog Maybe. by Ryan N and used with permission of the author. All other rights reserved by the author.
After 12 years in the veterinary medicine field as a nurse, I am actively focused on a career shift into computer science, specifically in software engineering.
This blog is where I will document my technological discoveries, achievements, setbacks, and anything else that contributes to conquering my career goals.
From the blog cs-wsu – Anna The Dev by Adrianna Frazier and used with permission of the author. All other rights reserved by the author.
During sprint 3, I kept working on the frontend, like the last sprint, I had been stuck trying to get the backend up, while trying to work on the frontend. I had a teammate work with me for this sprint to complete it. We worked on two different branches, mine and Jason’s. Inside my branch, I was having a problem starting up the frontend through development mode, so I decided to see the original branch and work back into the updates I had made. Jason was able to start the frontend without the backend using dev. This gave me the advantage of designing the frontend and seeing what would work. Working with someone this sprint improved the sprint overall for me because last sprint, everyone else was in the backend while I was working in the frontend. My teammates were helpful, but without working with someone directly in the frontend, it was difficult to get help on exactly what I needed.
First starting on the design, I had noticed that I had to make the banners and everything the perfect size, or it wouldn’t be eye-appealing. Small things like having the top and bottom borders being same size were important. One of my biggest problems was attempting to make sure the page could fit on one page without having to scroll, because, first, designing the front end, there would be empty white space that wasn’t needed, or having the logos be too small. But I was able to persevere and have a design that I was proud of. I also have to give credit to Byron, who posted his design, which I translated into my design. It helped in choosing what logos should be prioritized and gives the frontend a coherent design.
For this sprint, I would choose Kindred Spirits as the pattern that most resonated with me. This pattern highlights the importance of working together and working with someone who is like-minded and is determined to learn and accomplish their goals. This is great to have in a team because it allows teammate to grow together while also accomplishing their tasks. Working with a teammate this sprint greatly affected the amount of work I was able to accomplish. I was able to complete more in a shorter amount of time given. Directly working with Jason during this sprint gave me more insight into the issues we faced and helped me grow faster and feel more supported. Before this sprint, as I mentioned, I was isolated, working on the frontend by myself. It was difficult to troubleshoot my work with others because they were working on different aspects of the project, mostly in the backend. My teammates were helpful in what they could help me with, but there was always a disconnect because I didn’t want to slow them down on their work, and they were working on the backend. Working in collaboration with Jason allowed me to exchange ideas and confirm each other’s work. It gave me more confidence to ask questions because we were working in unison on the same problem. If I had been aware of this pattern earlier, I would have gotten a partner sooner because working in isolation isn’t a deterrent to just you but to the whole team.
From the blog cs-wsu – DCO by dcastillo360 and used with permission of the author. All other rights reserved by the author.
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.
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.
Software testing encompasses various methodologies, each targeting specific aspects of the application:
Testing is conducted at various stages of the software development lifecycle:
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.
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.
During this sprint, I switched up the work I did compared to the last sprint instead of working on the backend I was given the task to oversee the front end. First going into the front end blindly I didn’t know exactly how far the front end was already and had to accommodate myself to the code. First opening the frontend I noticed it was missing several files that would hold great importance in starting the frontend. One of my first fixes was the docker-compose file left by the other group was the backend file the same so I created a new file that would hold both servers of the front end and the backend. I updated some of the documentation that had been outdated compared to what we were working on currently. I created a new way to start the frontend server because it was missing that and added an up.sh, down.sh, and rebuild.sh for the front end. I also updated the outdated docker file. After I had a basis for what was needed I decided to go in and organize it better to read the new files in an organized manner to see what files were missing. Had to add new assets and components including new pictures of Libre food pantry and any other ones that were needed.
During this sprint, I worked well working alone but I should have checked more often with my teammates because of the issue that would later fall upon me. I was making progress every week but I hadn’t yet seen the biggest fault was the backend would crash on me. Next time I should check in with my teammates sooner instead of making progress on my own. I just didn’t want to slow down my teammates with my work. That is a fault in itself I shouldn’t be scared for help because the team will fail if I do this.
This time around the apprenticeship pattern that resonated with me the most was breakable toys because it is the basis of each sprint. You must create a small project where you can make mistakes in order to learn and be better. During this spring I was learning the ins and outs of the front end on something someone else created that I had to update and fix. This pattern could have made me more confident in messing up because it’s now wrong to mess up. Failing would help with issues that would come up that would show me what to do in other scenarios. Another pattern I would choose is to learn how you fail. I had many times during this sprint where I was head scratching to find an answer or come to an understanding of something but picking up on the patterns of how I failed I could change for the next issue that would come up. This issue opens my mind to being more intentional with my work and picking up on my common mistakes even if sometimes simple mistakes are the biggest headaches. Errors can be preventable by understanding why you do something and adapting to catch them next time. During this sprint, I learned a great deal about my project and I hope in the next sprint I will be able to learn more.
From the blog cs-wsu – DCO by dcastillo360 and used with permission of the author. All other rights reserved by the author.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.