Improving Code Reviews

In this blog post, I will be talking about the various ways one can make their code reviews better. The blog that I am referencing is titled “How to Make Good Code Reviews Better” and is published on the Stack Overflow blog. The blog post outlines multiple strategies for people to improve their code reviews. These strategies include maintaining a respectful tone, offering specific and constructive feedback, and trying to focus specifically on high-impact areas. Furthermore, the importance of maintaining a balance between efficiency and thoroughness is highlighted in the blog, as balancing those two is very important if you want to ensure that reviews don’t become a barrier for your team during the development process.

I chose this blog because I thought that it would be a resourceful blog to read through, as these strategies can definitely help in the future for my professional career. This also relates to what we learned in class, as the blog heavily focuses on collaboration which can be tied back to our discussions about agile development.

This blog made me realize that code reviews should not be harsh critiques, but rather helpful conversations that provide insight on what should be improved in your code. It shouldn’t feel like a negative conversation, it should be supportive and friendly which creates a better working environment. For me, it also brings encouragement, as workers will feel more encouraged to improve upon their code if their coworkers are actively supporting them. Code reviews should be focused on the “what” and “how” rather than just listing all of the flaws of the code.

The blog also mentions how people should be reviewing for the future by providing insights that extend beyond the immediate fixes in order for the code to have better maintainability. The reviews should, of course, fix the immediate problems, but should also set up the program for better and for consistent success in the future. It should be focused on the sustainability of the code rather than just fixing all the short-term problems but not addressing how it will look in years. In general, every line of code that one writes should be written with the long-term impact of said code in mind.

Going forward, I am planning on applying these strategies of good code review in my professional career as well as my current academic career. If I am reviewing the code of a peer, I will aim to give constructive feedback that makes it feel encouraging rather than simply telling someone all the problems with their code. Doing this creates a better workplace environment where people feel comfortable with expressing their thoughts and opinions about things, creating a better team atmosphere and promoting teamwork and collaboration. I will also welcome feedback from peers about my work, as it is important to listen to the feedback of your peers, as in the end we are all working together towards a common goal.

Link: https://stackoverflow.blog/2019/09/30/how-to-make-good-code-reviews-better/

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

AI Revolutions in Large-Scale Application Development

The advent of Artificial Intelligence (AI) is changing the software development landscape, making the creation of big project and their related application code faster, smarter, and more efficient. From automating repetitive tasks to optimizing code and enabling predictive analysis, AI empowers developers to achieve more with less effort. This blog explores how AI actual facilitated in normal coder and tester related workers and their tangible benefits give more reliable outcomes without any more works.

               AI acts as a force multiplier in software development, streamlining workflows, reducing errors, and enhancing productivity. Before AI the possibilities of traditional works are very lengthy and so much effort of manual strategy, particular for large projects. By using machine learning, natural language processing, and advanced algorithms, AI tools and platforms help developers at every stage of the application lifecycle, thus easing those challenges.

Key Areas where AI Growing:

Code Generation: In GitHub Copilot AI tools helps developers by generating raw codes, suggesting snippets, and writing full code according to their descriptions.

Bug Detection and Fixing: AI tools like Deep Code analyses coders code and give accurate and deeper result so it gives actionable recommendations in real bugs and fixes their uses in just one click.

Automated Testing: Machine learning algorithms can generate large scale test on minimum time so it actual carry the whole process testing in their application so workers can get time and effortless comprehensive testing.

Real-World Examples of AI in Action

  1. GitHub Copilot: This AI coding assistant generates suggestions in real time, helping developers write efficient and accurate code faster. It makes big projects easier to handle by lowering the amount of manual labor required for repetitive coding chores.
  2. Chatbots for DevOps: AI-powered chatbots doing multiple things automatically like server deployment, monitor application health, and resolve issue in one time so human interventions growth reduced.

Challenges and Limitations is also part of this AI skills. AI-generated code may require careful validation so might be Accuracy Dependence is requirement in project-specific parts. It may be necessary to make an initial training expenditure in order for developers to comprehend how to use AI tools efficiently. Using AI in proprietary projects brings up issues related to biassed algorithms and intellectual property so ethical issue is also fixed it our terms and modifications.

               As AI continues to evolve, its role in software development will expand further. Innovations such as generative AI for full-stack applications, intelligent debugging systems, and adaptive learning platforms will redefine what’s possible in large-scale application development. In conclusion, AI is not just a tool for coders; it is one robot which give accurate result without any further large skills task. Diverse controlling in AI based application is sometime give innovation and creativity and every computer fields.

Citations:

  1. GitHub Copilot Documentation. (n.d.). https://github.com/features/copilot
  2. Amodei, D., Olah, C., et al. (2016). Deep Learning in AI Systems. OpenAI Research Papers.
  3. Applitools AI Testing Tools. (n.d.). https://applitools.com
  4. How AI is Revolutionizing Software Development [YouTube Video]. (2023). Available at: https://www.youtube.com/watch?v=IGQChbLYFqY

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.

Understanding Technical Debt

In software development, technical debt refers to the extra work required in the future when quick, easy solutions are chosen instead of more thorough, time-consuming approaches. This concept is explored in the article “What is Technical Debt & How Can Companies Manage It?” by Coder Academy.

The article defines technical debt as the accumulation of suboptimal code or design choices made to deliver projects faster. While these shortcuts may lead to quicker releases, they often result in higher maintenance costs and reduced code quality over time.

Key Factors Contributing to Technical Debt

  • Time Constraints: Meeting tight deadlines can lead to hasty decisions that prioritize speed over quality.
  • Evolving Requirements: As project requirements change, older code may no longer align with the current needs.
  • Lack of Documentation: Poor documentation can create misunderstandings and increase errors, contributing to technical debt.

Strategies for Managing Technical Debt

The article suggests several ways to manage technical debt effectively:

  • Regular Code Reviews: Consistently reviewing code helps identify and address suboptimal practices early.
  • Refactoring: Improving existing code without changing its functionality can enhance readability and maintainability.
  • Comprehensive Documentation: Thorough documentation supports better understanding and future modifications.
  • Prioritization: Address technical debt based on its impact on the overall project’s progress and quality.

I chose this article because technical debt is a common issue in software development and is closely related to our course material. For Computer Science students, learning how to avoid technical debt is critical. If technical debt becomes a habit, it can lead to poor time management, less active learning, and weak decision-making skills. Understanding its causes and management strategies is essential for maintaining code quality and ensuring project success.

The article provided valuable insights into technical debt and its consequences. I learned that while quick fixes may save time initially, they often lead to higher maintenance efforts and system issues later. The importance of regular code reviews and refactoring stood out, as these practices can help reduce technical debt and improve code quality.

I also appreciated the visual diagrams and tables in the article, which made it easier to understand what technical debt is and how to manage it. I particularly liked the advice on avoiding technical debt and understanding its long-term impacts as a programmer.

By adopting the strategies outlined in the article, I aim to contribute to developing sustainable, high-quality software solutions. This knowledge will help me avoid accumulating technical debt in my future work. I am motivated to build new habits, such as maintaining good documentation, participating in regular code reviews, and prioritizing refactoring. These practices will help me become a more effective and skilled programmer.

Sources:
What is Technical Debt, and how can you manage it?

Citation:
Academy, Coder. “What Is Technical Debt, and How Can You Manage It?” Medium, Medium, 18 May 2016, medium.com/@coderacademy/what-is-technical-debt-how-can-companies-manage-it-1af08992f6d0. 

From the blog CS@Worcester – CodedBear by donna abayon and used with permission of the author. All other rights reserved by the author.

Git Tricks For the New Dev

I just recently finished learning about git in a classroom setting, so every step from forking to cloning to branching and staging then committing into pushing ending with pulling. All the parts to get the gist of git, but nothing in the way of advanced use. Enter this article written by Gitlab.

As its title suggests, “15 Git tips to improve your workflow” has 15 total tips in regards to git, so lets go through some of them together.
1. Git aliases; amazing function, to think that rather than checkout, branch, or commit I could use a custom name. This is, in my opinion, great for new devs since once they grasp the concept of what a command does they can alias it to something that makes sense to them.
2. Visualizing repo status with git-prompt.sh; needs to be downloaded but definitely a useful tool for people like me who benefit from a more visual experience.
3. Command line commit comparisons; definitely more of a practical command that is helpful to see your workflow. Definitely going to be using this one to help me track what I actually worked on and might even download the Meld tool they mentioned.
4. Stashing commits; another practical command that makes sense just for a dev to know. If you have to push a sudden fix in the middle of adding a feature you can stash the changes made for the feature, commit the fix and then just pop the stash to get back all the previous work.
5. Pull frequently; nothing to add.
6. Auto-complete commands; tab to automatically finish a word is also applicable in search engine prompts as well. So useful for a new dev since if they forget the command but remember the first letter they can just flick through the commands until they find what they were looking for.
7. Set a global .gitignore; create a list of files to remove from commits and put it on the exclusion list, nice and simple.
8. Enable autosquash by default; had to look this up, apparently the squash command merges commits into one big commit. Personally not too sure of the use case so will have to test it out at a later date.
9. Delete branches locally that remote removed when fetching/pulling; as part of fetch, there is a prune attribute that will work this functionality and it just needs to be set to true.

Obviously there are 6 more tips and they are: Use Git blame more efficiently, Add an alias to check out merge requests locally, An alias of HEAD, Resetting files, The git-open plugin, and The git-extras plugin. I will not go over them here but definitely give the article a read if you are interested.

Link:
https://about.gitlab.com/blog/2020/04/07/15-git-tips-improve-workflow/

From the blog CS@Worcester – Coder's First Steps by amoulton2 and used with permission of the author. All other rights reserved by the author.

(Week-14) Scrum Methodology in Software Development

Scrum is a widely-adopted framework in software development that is designed to encourage collaboration, smart time usage, adaptability, and transparency to deliver high-quality results to customers. The methodology centers around three roles: Scrum Master, Product Owner, and the Development Team.  Each role is critical to ensuring the scrum process is effective. Together, they uphold Scrum’s core values: commitment, focus, openness, respect, and courage.

The Roles in Scrum

  1. Scrum Master:
    The Scrum Master serves as the facilitator and coach, ensuring that the team will follow the Scrum principles. They steer the team away from distractions, help remove obstacles along the way, and guide the team toward self-organization and improvement. Their role is not necessarily  about managing the team but empowering it to achieve its goals effectively.
  2. Product Owner:
    The Product Owner is the voice of the customer, responsible for “maximizing” the product’s potential and value. They manage the product backlog, prioritize features based on the current sprint, and provide clear requirements to the team. They act as the bridge between stakeholders and the development team, ensuring that there is a complete alignment on goals and expectations.
  3. Development Team:
    The development team consists of software development professionals who collaborate to deliver increments of the product during each sprint. They are self-organizing, meaning they decide how to accomplish their tasks without intervention from the Scrum aster or product owner. This is great for fostering ownership, accountability, and for delivering high-quality work.

The Values of Scrum

Scrum is mostly made up of  five key values that the team’s behavior and decision making:

  • Commitment: Teams dedicate themselves to achieving sprint goals and delivering value.
  • Focus: By working on a limited set of tasks at a time, teams maintain clarity and productivity.
  • Openness: Transparent communication fosters trust and ensures that challenges are addressed collaboratively.
  • Respect: Team members value each other’s contributions and expertise, creating a positive and supportive work environment.
  • Courage: Teams take bold steps to innovate and tackle tough problems.

Why Scrum Matters

Scrum’s structured yet flexible approach enhances collaboration, reduces waste, and drives continuous improvement. By empowering teams to adapt to change and deliver incrementally, organizations can respond more effectively to customer needs and market shifts. Whether done in software development, marketing, or other fields, Scrum’s roles and values provide an amazing foundation for the success of a company.

Resource on Scrum Management

“What is Scrum in Project Management?” is an informative video about the Scrum methodology by the work management company Wrike.  This resource informatively explains all aspects of scrum, including but not limited to: goals, roles, practices, and examples.  It also explains the idea of a “sprint” which is the current goals of the development team that they must get done before the next sprint.  Check out the video for more information on Scrum Methodology.

Link: https://www.youtube.com/watch?v=M12HSYZkrgQ

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

Code with No License??

One of the incredibly positive aspects of the software development community is the general spirit of collaboration. This is particularly true within the open source software community. Paired with the fact that anyone can maintain a project/portfolio on GitHub, there is a lot of code out there. I would argue that this is a good […]

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

REST API History and Fundamentals

We have discussed REST APIs in class and are learning to use them with a practical, hands-on approach. This approach is faster for the course and is better for my understanding of the material, but I thought it would be a good idea to learn the history of REST APIs and expand my general knowledge of the subject. I found The Postman Team’s blog post, “What Is a REST API? Examples, Uses, and Challenges,” which discusses the fundamentals of REST APIs, including their history, standards, functionality, uses, benefits, and challenges.

The blog starts by explaining how REST APIs evolved from a simpler alternative to SOAP APIs, becoming the backbone of the modern web. With the advances in the internet during the early 2000s, developers and companies needed to be adaptable, which SOAP API was not the tool for. The post expands on the disadvantages of SOAP APIs and explains why they were less valuable at the time. SOAP APIs were not scalable and too restrictive, making it difficult for developers to innovate. REST APIs, on the other hand, gave companies and developers the flexibility and scalability needed to keep up with the internet as it evolved. Another key feature it had was independence. REST APIs are not tied to a platform or language and have client-server separation. The adaptability and simplicity made REST APIs an obvious choice for companies like eBay and Amazon.

The post also discusses some of the challenges involved with REST APIs. Some include maintaining consistent endpoints, managing multiple versions, and dealing with differing authentication methods. All these issues complicate the development and maintenance of REST APIs which is why there are standards used to mitigate problems in the future.

The blog’s final section showed REST API examples, including Amazon S3, Twitter, Instagram, and Plaid. It explained how each API has its own specialization, like Twitter’s registration process or Amazon’s ability for developers to incorporate AI.

What I found most interesting about the blog post was the timeline for REST APIs’ evolution, the big names that pushed REST APIs forward, and the reasons behind their actions. Major companies we know today, like eBay and Amazon, got ahead of the curve, leading the way for companies like Twitter and Facebook. Learning the reason behind its success and its practical uses was interesting. I will use what I’ve learned to approach future projects with a stronger understanding of REST APIs, ensuring I design scalable, adaptable, and efficient code.

Blog: https://blog.postman.com/rest-api-examples/

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

Importance of Git

Hello everyone

For this week’s blog topic, I will talk about the Importance of Git. I think this is one of the most valuable skills to learn and master in the computer science field as it is used everywhere. If it’s either working on a project for a class or at work, utilizing git would help your teamwork greatly.
The blog that I chose did a great job of explaining Git, even to a person who has never heard of it before. It starts by explaining its purpose which is: tracking changes, improving collaboration, managing project versions and even storing them. The highlight of git is how it empowers teamwork, and each developer can work on a shared project code together. Having the ability to streamline a team’s workflow through branching, merging, and pull requests. These features are what allows users to work independently on different tasks for the project. Someone could make a copy of the project and work on fixing a bug, another team member could make his own copy and then add a new feature to the project. Then these changes are seamlessly integrated back to the original project without any problem. Another amazing feature that Git offers is the ability of keeping track of version history that your project has gone through. You are able to trace through changes, even seeing who made them. Commenting on your own commits makes fixing bugs so much easier and accelerators the process. Another reason why this feature is amazing is that sometimes you add something new, or by fixing something you have accidentally broken the code. I know that has happened to me a lot before, and when I didn’t know what Git was at the time I had to manually save all my files, duplicating them so I could have that version of it saved just in case I made a bug and I wasn’t able to fix it. With Git you don’t have to worry about that, as it does that already for you. So if you wanna go to a previous version of your code you can always do that. Later on, the author of the blog talks about how Git positively impacts the quality of your code with all of its features. Git also encourages peer reviews, and by having automated testing, it ensures that only the thoroughly tested and clean code enters the main branch. With all of its cool features that it has, Git helps developers with their creativity. Allowing them to experiment with the code independently without disrupting the main code is amazing. This allows coders to play around with the code adding new features or ideas without worrying about crashing the project. What I liked about this blog was how it was written. The structure and the approach was easy to follow and read. It allowed even learners to understand all of Git’s features and its benefits. It took complex and hard topics and by showing examples it made it easy to understand for everyone.

Jain, Srashti. “The Importance of Git: Essential Version Control for Developers.” Medium, TechVraksh, 13 June 2024, medium.com/techvraksh/the-importance-of-git-essential-version-control-for-developers-dc5ca5600bda. Accessed 15 Dec. 2024.

From the blog Elio's Blog by Elio Ngjelo and used with permission of the author. All other rights reserved by the author.

A Student’s Perspective: Comparing GitLab and GitHub in Software Projects

In the world of software development, effective version control and collaboration is very important. Two prominent platforms facilitating these needs are GitLab and GitHub. The article “Difference Between GitLab and GitHub” from GeeksforGeeks offers a comprehensive comparison of these platforms, highlighting their unique features and differences.

The GeeksforGeeks article delves into the distinctions between GitLab and GitHub, focusing on aspects such as:

  • Continuous Integration/Continuous Deployment (CI/CD): GitLab provides built-in CI/CD capabilities, enabling seamless automation of the software development lifecycle. In contrast, GitHub requires third-party integrations to achieve similar functionality.
  • Self-Hosting Options: GitLab offers a free community edition that supports self-hosting, granting users full control over their repositories. Conversely, GitHub self-hosting is available only through its paid enterprise version.
  • User Permissions and Collaboration: GitLab’s free version allows for more extensive user permissions, including role-based access controls and protected branches in private repositories. GitHub imposes more restrictions in its free tier, such as limiting protected branches to public repositories and capping the number of collaborators in private repositories.

I chose this article because it provides a clear and concise comparison of GitLab and GitHub, two platforms integral to modern software development. Understanding their differences is crucial for developers and teams aiming to select a tool that aligns with their workflow and project requirements. I also chose this article because we use both platforms in class. In the beginning of the semester, if someone was to ask me what the main difference is between GitLab and GitHub. I would not be able to tell them.

The article enhanced my understanding of the operational variances between GitLab and GitHub. I learned that GitLab’s integrated CI/CD pipelines can streamline development processes by reducing reliance on external tools. This integration allows a more cohesive environment for managing code changes, testing, and deployment.

Additionally, the flexibility of self-hosting with GitLab’s free community edition offers significant advantages for organizations concerned with data privacy and security. It allows for greater control over the development environment without incurring additional costs.

The article also shed light on the importance of user permissions in collaborative projects. GitLab’s comprehensive role-based access controls in its free version facilitate better management of team contributions and code integrity. In contrast, GitHub’s restrictions in its free tier may pose challenges for larger teams or projects requiring stringent access controls.

Recognizing the importance of these platforms in the industry, I am committed to deepening my proficiency with both GitLab and GitHub. I plan to engage with comprehensive tutorials and hands-on projects to master their functionalities. By dedicating time to explore and practice with these platforms, I aim to position myself as a proficient user, ready to contribute effectively in professional settings where these tools are integral. This proactive approach will not only enhance my technical skills but also increase my employability in a competitive job market.

Sources:
Difference Between GitLab and GitHub

Citation:

“Difference between GitLab and Github.” GeeksforGeeks, GeeksforGeeks, 23 July 2024, http://www.geeksforgeeks.org/difference-between-gitlab-and-github/. 

From the blog CS@Worcester – CodedBear by donna abayon and used with permission of the author. All other rights reserved by the author.

Week 14

We have collaborated on the backend for the last few weeks. It is the central workload of our work, so I wanted to find an article about it. It very much intertwined with what were doing in class and outside of class with the homework. It is a great opportunity to see other people’s experiences working in the back end and real-life experiences. You can understand more things that we didn’t dive into the class by doing research and expanding our knowledge. That is why this week I found an article that specifically goes into detail about backend development.

The article starts by mentioning the importance of the backend and how it’s often overlooked because most of the spotlight is on the front end. The back end is like what is under the hood of a car you are happy when it works without having to open the hood. That being said the front end and back end work in tandem it’s not always necessary but for this scenario yes. The front is more the user-facing elements of a website. Like the text that is being displayed, graphics, buttons, and or anything the user interacts with.While the backend focuses on the behind-the-scenes work to make the website function. Outside of a car is the front end and its engine and other components are the back end. The backend is important to complete any user request by being safe and efficient. Security and efficiency are key processes of the backend for the user experience. This is why both backend and frontend developers must work in unison to create successful applications. The main importance backend developers should go for is innovation. Technology is always evolving and people must adapt to it becoming stagnant won’t be successful in this field.

Reading this article made me understand more about backend development. Backend development has so much more to it with data and security. It makes sense because security is often overlooked at times. The more information is stored online the more we have to make the effort to secure people’s data. Nobody will want to use your application if there is a breach of security. My main takeaway was their statement about innovation. Their final message to the reader was a hopeful one stating that a developer must change with the times because they are in the epicenter of it. Technology goes far out including healthcare solutions that might not be important to some but are highly integral to a lot of people.  

https://www.ciat.edu/blog/understanding-backend-development/

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