Category Archives: CS-348

Clean code and reality.

 

The
article examines the question, “is clean code by Robert Martin still matters?” From
author’s 16-year coding experience, he writes about reality in writing clean
code and its criticism. He acknowledges that t in the end meeting the deadline
with functional and bug free code is more important then elegant code following
the principle of clean code. However, he argues in the end as a developer,
trying to integrate small aspects of clean code into your code base is going to
make your skill improve as an engineer in the long run even if many people will
not care about it.

I selected this
article as it addresses some uncertainty that I had with clean code. All the
code I have written feels like I got pressure to deliver functional code as
quickly as possible and now I’m supposed to write elegant, maintainable code so
I wanted to see the real live example from experience if clean code was that necessary.
The author’s real-world experience and practical approach toward the subject made
it an interesting topic to delve into deeper.

This article showed
that clean code is not something you have to write all the thing following to
it, it is about finding the right balance between quality code following the
clean code and functional code. I feel like clean code still matters in a bit
as we want to write a code in time but needs to make it modular to be abled to be
easily refactored for later uses. Not only that, this article advice to start
small feels realistic and something I can do to grow as a programmer.  The hierarchy of what matters in the software
part will be my checklist in the future as it is the basic outline of how the
code needs to be structured. When writing code, the working code always comes first,
then make it without bug and if there is bug, you should be able to be fixed
easily then I will try to add instance of small parts of clean code in. I want
to make the code a bit modular because I spent hours trying to refactor code sometimes
and finding which part of the code went wrong took a long time because my code
was always a mess. Therefore, I feel like idea of clean code by Robert martin
is not dead but only small part of it is still alive to become better
programmer. As the most important thing for programming is to make software
that is easy to maintain, adapt and scale.

 

Article
link :
https://tommcfarlin.com/who-cares-about-clean-code/

 

From the blog Sung Jin's CS Devlopemnt Blog by Unknown and used with permission of the author. All other rights reserved by the author.

Clean code and reality.

 

The
article examines the question, “is clean code by Robert Martin still matters?” From
author’s 16-year coding experience, he writes about reality in writing clean
code and its criticism. He acknowledges that t in the end meeting the deadline
with functional and bug free code is more important then elegant code following
the principle of clean code. However, he argues in the end as a developer,
trying to integrate small aspects of clean code into your code base is going to
make your skill improve as an engineer in the long run even if many people will
not care about it.

I selected this
article as it addresses some uncertainty that I had with clean code. All the
code I have written feels like I got pressure to deliver functional code as
quickly as possible and now I’m supposed to write elegant, maintainable code so
I wanted to see the real live example from experience if clean code was that necessary.
The author’s real-world experience and practical approach toward the subject made
it an interesting topic to delve into deeper.

This article showed
that clean code is not something you have to write all the thing following to
it, it is about finding the right balance between quality code following the
clean code and functional code. I feel like clean code still matters in a bit
as we want to write a code in time but needs to make it modular to be abled to be
easily refactored for later uses. Not only that, this article advice to start
small feels realistic and something I can do to grow as a programmer.  The hierarchy of what matters in the software
part will be my checklist in the future as it is the basic outline of how the
code needs to be structured. When writing code, the working code always comes first,
then make it without bug and if there is bug, you should be able to be fixed
easily then I will try to add instance of small parts of clean code in. I want
to make the code a bit modular because I spent hours trying to refactor code sometimes
and finding which part of the code went wrong took a long time because my code
was always a mess. Therefore, I feel like idea of clean code by Robert martin
is not dead but only small part of it is still alive to become better
programmer. As the most important thing for programming is to make software
that is easy to maintain, adapt and scale.

 

Article
link :
https://tommcfarlin.com/who-cares-about-clean-code/

 

From the blog Sung Jin's CS Devlopemnt Blog by Unknown and used with permission of the author. All other rights reserved by the author.

Clean code and reality.

 

The
article examines the question, “is clean code by Robert Martin still matters?” From
author’s 16-year coding experience, he writes about reality in writing clean
code and its criticism. He acknowledges that t in the end meeting the deadline
with functional and bug free code is more important then elegant code following
the principle of clean code. However, he argues in the end as a developer,
trying to integrate small aspects of clean code into your code base is going to
make your skill improve as an engineer in the long run even if many people will
not care about it.

I selected this
article as it addresses some uncertainty that I had with clean code. All the
code I have written feels like I got pressure to deliver functional code as
quickly as possible and now I’m supposed to write elegant, maintainable code so
I wanted to see the real live example from experience if clean code was that necessary.
The author’s real-world experience and practical approach toward the subject made
it an interesting topic to delve into deeper.

This article showed
that clean code is not something you have to write all the thing following to
it, it is about finding the right balance between quality code following the
clean code and functional code. I feel like clean code still matters in a bit
as we want to write a code in time but needs to make it modular to be abled to be
easily refactored for later uses. Not only that, this article advice to start
small feels realistic and something I can do to grow as a programmer.  The hierarchy of what matters in the software
part will be my checklist in the future as it is the basic outline of how the
code needs to be structured. When writing code, the working code always comes first,
then make it without bug and if there is bug, you should be able to be fixed
easily then I will try to add instance of small parts of clean code in. I want
to make the code a bit modular because I spent hours trying to refactor code sometimes
and finding which part of the code went wrong took a long time because my code
was always a mess. Therefore, I feel like idea of clean code by Robert martin
is not dead but only small part of it is still alive to become better
programmer. As the most important thing for programming is to make software
that is easy to maintain, adapt and scale.

 

Article
link :
https://tommcfarlin.com/who-cares-about-clean-code/

 

From the blog Sung Jin's CS Devlopemnt Blog by Unknown and used with permission of the author. All other rights reserved by the author.

Workflow for a Developer


This week, I came across an post titled “Improving Developer Workflow” on Vercel’s blog, and it caught my attention because I’ve been trying to figure out how developers stay productive while coding. The article dives into different ways to make workflows more efficient, focusing on tools and practices that help developers ship better code faster. Since I’m new to computer science and still figuring out how to work effectively, this post felt super relevant to my learning journey.

The post highlights key aspects of improving developer workflows. It starts by discussing the importance of having fast feedback loops, meaning developers should quickly see the results of their code changes. This post introduces tools like Vercel’s platform, which makes it easy to preview, test, and deploy changes almost instantly. Another focus is on collaboration, emphasizing how tools like GitHub help teams share work and review code seamlessly. It wraps up by stressing the value of automation, like setting up CI/CD pipelines, to reduce repetitive tasks and ensure consistent quality in the codebase.

I chose this post because workflow optimization feels like an essential skill for any developer, even beginners. Sometimes I get stuck on repetitive tasks or wait too long to test my code changes, which can be frustrating. This post seemed like a good way to learn how experienced developers streamline their processes. Also, tools like GitHub and CI/CD were mentioned in class, so I wanted to understand them better.

The main thing I learned is how fast feedback loops can save a lot of time and frustration. For example, using tools like Vercel lets developers instantly preview their changes in a live environment, so they don’t have to guess if their code works. I also learned how CI/CD pipelines automate testing and deployment, which not only saves time but also reduces the risk of errors. I realized that these tools make a developer’s life easier, but they also require some setup and understanding, which I’m excited to learn more about. Another cool takeaway was how much collaboration matters in a developer’s workflow. I’ve used GitHub for simple projects, but the blog post made me realize how powerful it can be when teams use it for pull requests, code reviews, and tracking changes.

This blog post made me want to improve my own workflow by setting up faster feedback systems, even for small projects. I also plan to explore tools like GitHub Actions to try basic automation for testing. In the future, I hope to use these techniques to work more effectively on team projects and avoid common frustrations like repetitive tasks.

Resource:

https://vercel.com/blog/improving-developer-workflow

From the blog Computer Science From a Basketball Fan by Brandon Njuguna and used with permission of the author. All other rights reserved by the author.

A Strategic Approach to Code Review

A blog that recently caught my attention was GitHub Engineer Sarah Vessels, “How to review code effectively: A GitHub staff engineer’s philosophy”. Vessels focuses on code review every single day which has brought her to create her own strategies for successful code review to ensure we are building good software. Though code review can be done in different ways I selected this blog because it directly involves code review via pull request reviews on GitHub which aligns perfectly with our classwork over the past couple of weeks learning to manage Git properly.  

One large part of Vessels job as a code reviewer is having an open discussion with the author of the code posing questions that may have not yet been considered. The phrase two sets of eyes are better than one comes to mind here as we can very frequently catch other’s coding mishaps, but we might miss our own. The writer stresses that acting as a reviewer for another teammate benefits both parties as the reviewer is constantly seeing someone else’s logic and new code, while the author of the code is gaining a new perspective – this exchange of knowledge is extremely valuable. 

This blog also provides tips and tricks of how to manage a queue of pull requests properly providing simple Slack queries to organize new requests by team or outstanding requests that require attention. Another tip from the writer is ensuring the reviewer team stays small – this benefits the development team overall as there is clear accountability for who is to review the changes. Vessels also commented on the benefit of specifying code review requirements/frameworks to ensure a seamless, consistent review process amongst teams.  

The writer also provides samples of good code review feedback and poor code review feedback to highlight the main differences between them. Good feedback should include specific details, references to specific issues/lines, provides a possible solution, and provides reasoning. This blog post also offers vital information related to how to give a good code review. Some of the tips seem like common sense like offering affirmations and asking questions, but an important tip Vessels shares is to be aware of biases and assumptions. The writer highlights that even the most-senior programmers can make mistakes so only you (as the reviewer) have the opportunity to validate the work and catch any issues before deployment.  

GitHub Engineer Sarah Vessels shares her invaluable experience with code review through this blog post which discusses fine-tuning the review process, good vs bad reviews, how to give good reviews, and how to get the most out of a review. As a student, it is often my own code that I must turn back to and review to enhance, but after this reading I am feeling encouraged to seek opportunities to study others code with a focus on the exchange of knowledge and getting experience on my own for how to review code for a development team in the future. 

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

Software Licenses

Hello WSU blog! In this post I am going to talk about what I learnt in class in regards to software licenses. We watched an informative video on it in class, and then we worked in groups to practice with the information from the video. I actually learnt a lot of simple things about copyright that I never noticed until this class. One thing I learnt was that there is actually an automatic copyright for things that you don’t license. This means that if you want someone to be able to legally use your code, you HAVE to license it, and pick the permissions that they have to use your code. When you license your code, you do not in fact give up your copyright. The copyright will always belong to you, however licensing it lets other people use your code in certain ways.

In this activity we also compared two different licenses. We compared the MIT License, and the GNU General Public License. The MIT License is simple and permissive, meaning that it allows the users of the code to do more things with it. On the other hand, the GNU General Public License has a few more conditions, such as disclose source, same license, and state changes. An extra permission for the GNU license is Patent use. We also briefly looked into non-software licenses as well.

The blog post I researched for this week’s blog is linked here: What is a Software Copyright?

I chose this blog to research because it was pretty simple and easy to understand, while also being very informative. This article mentioned HOW exactly your software is protected due to copyright licenses. It talked about points we covered in class, such as the automatic copyright, which is put into play as soon as the software “is created and saved in some way.” The way the software is written is protected by copyright law, and the owners of the software can give other people access/permission to use their code with the use of licenses. The article also concluded by emphasizing the importance of software licensing and how essential it is for people who want to create or use shared software.

Overall, I think that learning about this stuff while we are still in college is important, and I am glad my professor took the time to include this in the content of this course. Copyright and Licensing is important, and it prepares us a little bit more for the future and real-world applications.

From the blog cs@worcester – Akshay's Blog by Akshay Ganesh and used with permission of the author. All other rights reserved by the author.

Version Control apply in cooperative work VS Student life

Each organization in the modern world invests thousands of dollars in Agile development. Agile offers a lot of advantages, but the business only creates successful tactics, and version control is one of them. For computer science students, becoming proficient in Agile not only increases your hands-on expertise but also helps you master your surrounding team environment.

Version control and Agile methodology give you more power for your frequently changing things. This principle provides quick adaptation and mastery in changing technology, so every team manager can robustly improve their performance with a good mindset. Chances in everyday situations also play a part in our tasks as a team. Agile is simply one technique; your team’s performance depends on more than just one mindset. It affects our environment’s inevitable glitches and bugs. It also upgrades one mindset through team-leading performances. Quick adaptation is also most crucial role play in student academic career. How fast you adopt things and applied it that things in right place with good understanding gives more benefits in your career goals. Today’s world is not steady because everyday life changing and new things come and go so adaptation according to chances is play key role in every sector. Students want to know how agile control flow their mind in different scenario. Version control allows students to create real-world scenarios in which multiple team members work on various parts of a project at the same time.

Key Benefits for Students

Enhanced Collaboration – Version Control enables students to work on multiple group activities in one time and also check their work and give meaningful work problems skills optimizations so students can easily learn multiple things in a single time and apply it in the job market.

Timing Ability – Focus on their project evolution completed in a proper way with time to time is implementing a tracking system and accountability. This not only helps with understanding the development timing but also cultivates a sense of accountability for program improvements.

Developing To Take Risk Ability – New ideas working in their plans without fear it’s creating a more advanced process. This encourages new modern art, helps to solve your error, and enhances your taking ability skills. 

In conclusion, vision control in Agile is powerful in the cooperative and student worlds. These benefits help a lot in your future career processes, so applying them with proper thinking creates delivery methods and boosts your career. Students helps these advanced weapons in the real world, so learning and understanding the whole process makes humans more powerful.

November 29, 2024

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.

Github Utilization

Github has probably been the most useful tool I’ve ever used when collaborating with other team members or co-workers on projects. Even though I have used it for quite some time now there are many resources out there on the basics that still help me in figuring out the tool. One of many that I found was actually on the Github blog itself under the developer skills section which has a guide to a good amount of the basics themselves. Here is a link to just one of the sections relating to pull requests https://github.blog/developer-skills/github/beginners-guide-to-github-creating-a-pull-request/. For anyone new to using Github these guides seem incredibly useful, they include videos, pictures and recaps for everything discussed.

Just recently we went through Github in our CS-348 course and I did end up referring back to this source to help me in getting a refresher and understanding the content better. These guides go through a step by step process in explaining how each of these functions such as pull requests and merging works. Each subsection of explanations also includes pictures and videos themselves to help the reader better understand what they should be seeing when following along with the process. One of the most recent posts in the beginners section also included the setting up and securing of the users profile as seen here https://github.blog/developer-skills/github/beginners-guide-to-github-setting-up-and-securing-your-profile/. This is one of the most basic of the basics that pretty much everyone that uses the internet should know about, but you would be surprised at how many actually do not take this part seriously. Thankfully in this post the author describes the use of 2FA and how to set it up, 2FA is one of the easiest ways to secure your account much better than just using a password. At the end of each of these lessons / posts, the author includes a “Your next steps” section that allows the reader the use of a repository to test with if the lesson declared the use of a repository, or it will point you in the next direction you should take.

Overall this blog is probably one of the most effective ways for someone who is just learning Github to get used to a bunch of the basics. I only found this blog just recently but I much prefer it over a youtube video itself since it guides you through each step with a good amount of detail and it is very easy to go back any time I need to and re-read specific steps or details. Since not all of the basics have been published yet I will most likely keep my eye on this blog because reinforcing the basics if you are not sure about something is always helpful.

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

Takes on how to become an effective team

URL: https://www.youtube.com/watch?v=7zDX8VqvBa0

I came across another interesting podcast episode from Beyond Coding. This time, the episode I watched focused on Effective Product Teams, featuring Anne Kooijman, currently a Product Owner at Coolblue. The conversation between her and the host covered various topics related to team management and ways to build an effective product team.

The reason I chose this resource is that it provides real-world solutions to straightforward questions. The host, Patrick Akil, mentioned that he recently took on an assignment as a Project Manager. He asked many interesting questions, some of which I had myself.

A couple of specific points caught my attention, and I’d like to share them with you. The first was Anne’s perspective on what is required for a team to deliver quality work. She said, “Give them the necessary tools and the theoretical background.” I found this fascinating because you shouldn’t give developers half-baked solutions or dictate how to solve a problem. Doing so might make it harder for them to translate someone else’s idea into code. Instead, provide them with the necessary knowledge and tools to figure out solutions on their own and let them do it.

Another topic Anne discussed was how companies sometimes deviate from the core principles of Scrum and the potential outcomes of those deviations. She pointed out that there’s no issue with straying from what the “constitution” of Scrum dictates if it leads to improvements. This is intriguing because Scrum is meant to provide a framework, not a rulebook. Different teams consist of different people who may respond differently to certain changes. Personally, I imagine that I wouldn’t react well to constantly changing sprint durations.

They also discussed goal-driven teams and how having goals is essential for team effectiveness. This resonates with me, as it aligns with a practice, I adopted this semester. This isn’t meant to criticize how others manage their responsibilities but to connect the podcast’s ideas with my own experience. For the first time this semester, I decided to only consume entertainment during my free hours once all my tasks were completed. It sounds simple and cliché, but it works—just like Scrum. Teams need a singular goal, and the focus should remain on that goal.

This brings us to the final topic: timelines, and how even flexible and inconsistent timelines can be better than having none. This concept challenged something I’ve always believed—that if you’re going to do something, do it right and to the best of your abilities, or don’t do it at all. However, I realized that some flexibility in timelines is necessary to allow for adaptation and growth.

From the blog CS@Worcester – CS Today by Guilherme Salazar Almeida Nazareth and used with permission of the author. All other rights reserved by the author.

Software testing

Software testing is verifying that a software product performs the way it is designed to.  The benefits of software testing are preventing errors or bugs from being in a program. When doing software testing, it is best to do testing during the start of a build, during the build, and after the deployment or release of a program. Through doing software testing, developers and companies can ensure there are no defects, or issues before releasing or prompting a product. If there are bugs or defects in company products, there is going to be a loss in customers and money. Some of the different types of software testing include acceptance testing, unit testing, and security testing. Acceptance testing is ensuring that a coding program runs and that there are no errors. Unit testing is testing parts of a program instead of testing a whole program. In  Unix systems programming class, I was exposed to unit testing in homework projects, where I had to write parts of a program and receive a grade for each part, and couldn’t move forward until receiving full credit on a part of a program. Unit testing can lead to fewer errors than acceptance testing. It is a better practice to test your code small bits at a time than to run a whole program. Security testing is ensuring that software programs are safe from hackers that could lead to being denied access to your software, or your software working incorrectly.

Software testing was first developed after the ending of world war two. Computer scientist Tom Kilburn wrote the first piece of software by performing mathematical calculations. Debugging was the main testing strategy at the time. By the 1980’s there were other strategies of software application testing outside of fixing bugs and errors. The process of software testing includes determining a testing method to use, developing test cases or setting up requirements for the test, writing scripts or parts of a program, analyzing test results, and writing a report. For large software programs, there are tools used to complete tasks and work on running tests for different tasks, with instant feedback on what works or not works for a program. Through reporting and analytics, teams can present their results in a dashboard, which would allow everyone to see the overall result of a project. Reporting results show how testing the product leads to the result. 

Blog url: https://www.ibm.com/topics/software-testing

From the blog CS@Worcester – jonathan's computer journey by Jonathan Mujjumbi and used with permission of the author. All other rights reserved by the author.