This week I discovered a blog that caught my attention. The blog discusses the incorporation of psychology into the process of software development. Spending extended periods seated, analyzing codes, searching for logical operations and function calls can exhaust our cognitive abilities. The fatigues could lead us to feel cloudy and have poor resolution. It goes deeper into the mind of a software developer mind on how one’s retain information, problem-solving approach, perceive the behavior and structure of what they’re building. It introduces study concept such as spaced repetition and interleaved practice that have been proven to enhance a person to learn new programming languages or frameworks. I believe that integrating psychological insights into software development can help enhance both individual mental well-being and professional skills.

The blog has eight topics, one of the first paragraph of the first one said,

“A team that communicates openly and respects each member’s input is more likely to solve problems effectively and innovate. On the other hand, a team mired in unresolved conflicts and poor communication can derail even the most promising projects.”

“Linking these psychological insights to Agile practices offers a fascinating avenue for enhancing team-based methodologies. Agile’s iterative approach and emphasis on collaboration are well-suited to leverage the strengths of a psychologically savvy team.”

While managing my team during group activities on Methodology, I believe it is more beneficial for everyone to feel comfortable being their authentic selves rather than feeling anxious and reserved. I think the idea of Agile practices can assists them in expressing their ideas and feeling at ease within the group. Continuing to utilize Agile methods can result in increased efficiency and effective communication within a team to meet project deadlines.

“I recall an instance where a single line of feedback transformed a junior developer’s approach to coding. It wasn’t my code review that pointed out the errors; it was my remark about his unique problem-solving skills that made his eyes light up.” I concur that helping one another to solve a problem or code in an easier way because everyone have different background with coding. Therefore, feedback and mentoring is crucial when it comes to coding. One person code could load faster and less complicated than another. Positive reinforcement can amplify a person’s strengths.

Reading this blog helps me understand how psychology is integrated into software development. All of these aspects, such as team-work, leadership, problem-solving, cognitive biases, feedback, and coaching, can be advantageous when viewed through a psychological lens. It motivates us to improve ourselves and others by helping each other enhance our skills and cognitive abilities. Where we find inspiration daily.

Blog URL: https://betterprogramming.pub/integrating-psychology-into-software-development-c5f79fc8019e

From the blog CS@Worcester – Matchaman10 by tam nguyen and used with permission of the author. All other rights reserved by the author.

Agile is a set of values and principles that software developers and/or managers use to encourage a positive work environment that is efficient, and promotes a successful workflow.  Agile is becoming the gold standard for software development and programming, because it is inherently based on collaboration.  Not only does it encourage intense collaboration with members of the development team, but also the customers they are making the product for.  A core tenant of Agile is to not only keep the team on the same page, but also stay transparent with the customer and accommodate their every need with the product.  Here are some important values and principles Agile is based on: “Working software over comprehensive documentation”, “Simplicity”, “Responding to change”, “Customer collaboration”, “Human communication”, and last but not least: “Continuous attention to technical excellence”.  These aren’t the only values, but they are some of the most important ones. 

“An Ultimate Guide to Agile Software Development” is an informative video about Agile Software Development, by the YouTube channel Invensis Learning.  In the video, the narrator discusses how Agile is beneficial for teams specifically in the Software Development field.  They describe Agile Software Development as a “set of iterative software development methodologies in which requirements and solutions arise from collaboration among self-organizing cross-functional teams”.  This is very important to understanding Agile, and its uses in the workplace.  Agile allows for teams working on different parts of a project to stay on the same page, and not get ahead of their peers, while still having room for improvement and disagreement.  They also go on to explain how a company following Agile doesn’t necessarily mean there isn’t a manager coordinating these things, but it suggests that each sub-group should be able to handle their problems on their own.  The video also discusses the “Agile Software Development Life Cycle”, which touches on how Software Development teams should roughly plan out their work for a product.  The cycles can differ from company to company based on the amount of employees, type of work, customer expectations, etc.  But, the values and principles should stay the same to maximize Agile efficiency.  The Agile Life Cycle follows six important steps, Concept, Inception, Iteration, Release, Maintenance, and Retirement.

To sum up today’s topic, Agile is a set of values and principles primarily used by software developers to make the workplace much more efficient and stress-free.  Agile promotes customer collaboration, and in-house collaboration with peers to ensure the product is as perfect as possible.  Over time, most software development companies will come to develop these principles, as they have been proven to be one of the best work strategies.

LINK TO VIDEO: https://www.youtube.com/watch?v=Evl5f2CnR08

• Elliot Benoit

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.

This blogpost by Martin Fowler was very interesting! It gave a very thorough and comprehensive look into what makes the agile methodology so different from older methodologies, which were very bureaucratic and abrasive when it came to change. It also showed why the principles of the more flexible, adaptive agile methodology helped to give more freedom to the developers and helped to create a better product for the developer’s clients. Reading all this put it into perspective for me how I will most likely be using this methodology in the future when I eventually go out to begin working and how this would really help to tighten up a team’s workflow and give them a better ability to put out a quality product. I really liked how as the post progressed there was a sort of small history about agile and how this blogpost was originally actually a means of pulling together most of the original ideas for the agile methodology in the past. I also understand now that agile really is just a perspective you need to have while working with a team and for a client that will help you to maintain a positive relationship with customers and maintain an efficient team. In the future I can assuredly see myself being apart of or using this methodology to develop software as it seems to be much more effective than older methods. The only thing I need to really look forward to is actually attempting to use the methodology as I don’t really have an understanding for how it would actually work or flow in practice. In essence, I think I picked this most of all because I still had questions about agile that have thoroughly been answered now, but I overall I hope for a chance to give it a try eventually in the future.

Summary: An in-depth discussion examining the difference in principles between the different methodologies of software process and an essentially original look at how agile developed and its methods, while also giving a sort-of mini history about agile and what it meant and means to developers.

Reason: I wanted a better more all-encompassing understanding of agile as I feel like I had heard this term outside of the course before, so I investigated it and came across this blog-post that seemed like it had a very detailed examination of it.

Blog Link: The New Methodology (martinfowler.com)

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

Looking back at this blog post it is a bit outdated, being posted nearly 2 decades ago but I still feel like it has a lot of quality information within it that can still be used today. I learned about several different architectures and their patterns that I thought were rather interesting. It was still a little over my head with a lot of jargon I didn’t understand, such as “Forms and Controls” and “Model-View-Controller” which is an apparently highly misconstrued architecture, that I had to look up, but I think this gave me a good look into what I can learn more about and where to direct my attention. I think in the future after I’ve learned some more basic architecture and design concepts, I’ll really be able to apply them and understand them more. Also, I’m a lot more interested in seeing more front-end things related to GUI and the process of developing a quality and useful GUI for a user. Now looking back at myself a little bit, reading this has really cemented for me how much I don’t know about the entire software development process. It truthfully shows me how I need to really pay attention and really work harder at developing my knowledge in the field as most of the blog post was entirely new to me and things I had never heard before which gets me excited about learning more! Also, all of the diagrams in the blog post were really neat and had a great effect in helping me understand the points of each pattern, so this has kind of helped me to understand how useful UML diagrams are and would be for designing and putting a program into and understandable and digestible format that makes it really simple to at a glance get what’s happening. I do think for my next blog post I may need to pick something a bit more my speed.

Summary: An interesting exploration of various architectures for GUI design and detailing their features as well as their underlying patterns within the architectures. Also is a sort of “intellectual history” of these varying GUI architectures.

Reason: I wanted to learn a bit more about GUI’s and how they work, this really details an almost historical record of UI development and how they work underneath. It also contains plenty of diagrams and detailed explanations that really helped me to better understand it.

Blog Link: GUI Architectures (martinfowler.com)

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

Blog Title: Exploring Software Development Methodologies: A Review

This week while searching for a blog I came across Kacper Rafalski’s blog post titled Software Development Methodologies: A Comprehensive Guide, which dives into the wide range of methodologies used in software development. From a few google searches I learned that Rafalski is a well established figure in the tech industry, known for his skills and knowledge in structured development processes, and his work provides insights on how various methodologies, such as Agile, Waterfall, and Lean, shape the success of software projects. In this post, Rafalski emphasizes the importance of choosing the right methodology based on project goals, team dynamics, and what a client needs. 

To start, Rafalski begins by explaining traditional methodologies like Waterfall, which follows a straight line in a downward sequential structure; this method is ideal for projects with clear, unchanging requirements. He contrasts this approach with the agile methodology, known for its repetitive and flexible approach, which accommodates changing client needs and fosters collaboration. Agile, according to Rafalski, prioritizes working software and client feedback over long and boring documentation, this makes it really useful in a fast paced working environment. He also highlights Lean one we have not covered yet in class hopefully soon. Lean is designed to  eliminate waste and maximize efficiency by focusing only on value-adding processes. He lastly mentions the newer methodologies, including Rapid Application Development-RAD and the Spiral model; each of them presented unique solutions for some particular project obstacles such as rapid prototyping and risk management.

I chose this blog posting for the following reasons: firstly, because it broadly and in great detail covers methodologies, highly relevant, therefore, to our course material. The tone of Rafalski is approachable and informative; he shows throughout by explaining complex subjects without getting too complicated on the reader.  I also liked his balanced discussion of the methodologies, which gave me the chance to think on how these approaches may apply to different software programming projects that I may encounter in my future. Also, the organization of the post makes it clear to follow and understand each methodology clearly. 

Reading this post clarified how to choose the appropriate methodology for a project. I really came to appreciate Agile’s iterative process and how in such an approach, adaptation to circumstances and collaboration is greatly enhanced, something that I hope to apply in future team projects. Generally speaking, I really recommend this post by Rafalski to anyone who wants to get a clear understanding of the diverse landscape of software development methodologies. This is not only an informative guide but also highly practical in field practice for software development.
Link to the post: Software Development Methodologies: A Comprehensive Guide

From the blog CS@Worcester – Harley Philippe's Tech Journal by Harley Philippe and used with permission of the author. All other rights reserved by the author.

As the first blog post, and naturally occurring when at the start of my CS-343 class, I had a hard time picking a topic. In class we haven’t gone over many new concepts, but my professor did mention during a topic review that there are other options from inheritance that are able to do very similar functions. Piquing my interest, I wanted to look into inheritance itself and what other people thought of it and compare it to my experience coding programs using inheritance.

The blog post I chose started with an introduction about how inheritance is taught in a way that doesn’t give students the best grasp at how to implement some of the more niche situations or real-world cases where inheritance would be the most efficient method. Something that the blog mentioned that has been something that as a student I have never really come across, is deciding when a certain method, in this case inheritance, is the best way to solve a problem. Usually with assignments, the method is already predetermined, and the implementation is what you are graded on, or because of the limited subjects covered, the intended method is easy to figure out.

The author then goes into the two main problems that inheritance has, the complex syntax and the complexity of the problem inheritance is best suited to. Inheritance has it’s own syntax that is new and you have to learn but it also gets difficult because the new context of the code now has new rules to it that need to be considered such as precedence, overriding, and variable types. The other problem is that cases where inheritance would be the best implementation are problems that have a reasonable amount of complexity. There needs to be two classes of objects that have a good deal of similarity between them but also be different enough and have a good amount of shared code to where you would not want them to be two separate classes. 

Reading this blog as well as reviewing inheritance in class has shown me that while I know the concepts and am able to write a program that utilizes inheritance, my experience with all of the special cases and interactions is not complete. The blog was more catered to teachers but as a student I also found it to be helpful. The blog doesn’t offer much in terms of a deeper look into the topic or language specific examples, but having learned more about it’s complexity I will be sure to look at other resources that more thoroughly and meticulously go over the nuances of inheritance so that I can feel confident in implementing it in any program where it would be a proper fit. I think it’s always good to try and fully understand a topic especially when you think you know everything about a topic and you run into a roadblock. 

Teaching Inheritance – Ada Developers Academy

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

In today’s digital world, good software management is critical for delivering high-quality products that meet user expectations and business goals. Modern software management refers to practices that help the software development processes. I decided on a source that highlights the key principles of modern software management, offering keen insights into how these practices enhance software delivery. While also having good project outcomes. This blog post summarizes these principles, explains their importance, and all while I’ll be providing personal reflections on how they align with my learning in my current course

The resource I selected talks about various aspects of software management, focusing on principles like Agile methodologies, Continuous Integration and Delivery (CI/CD), DevOps collaboration, user-centric design, lean software development, quality assurance, and data-driven decision-making. 

• Agile Methodologies: Emphasize flexibility and collaboration, allowing teams to respond to changing project requirements efficiently. Not A tool, Not A method, 
• CI/CD: Streamlines software delivery through automated testing and integration, improving the reliability and speed of releases.
• DevOps: Promotes collaboration between development and operations teams, reducing silos and enhancing overall efficiency.
• User-Centric Design: Prioritizes customer/user needs by using feedback and ensuring the software meets real-world requirements.
• Lean Software Development: The main goal is to eliminate waste, continuous improvement, and maximize value throughout the development process.
• Quality Assurance: Ensures the delivery of high-quality software through complicated testing and monitoring.
• Scalability and Flexibility: Encourages designing systems that can scale and adapt to changing needs, ensuring long-term viability.
• Data-Driven Decision Making: Uses metrics and insights to make informed decisions and drive continuous improvement.

I chose this resource because it provides a comprehensive overview of the key principles of modern software management, which happens to be the whole point of my class. These principles are directly applicable to the course material, which focuses on effective project management strategies and best practices for software development. Understanding these principles and getting an early understanding will help me in 0the future of this course. 

Personal Reflection and Application

Reading this resource helped me learn several key concepts from my coursework, particularly the importance of Agile methodologies and CI/CD in promoting flexibility and efficiency considering we had worked on it today. For instance, I learned how Agile’s iterative approach allows teams to remain adaptable, responding to feedback and shifting priorities without losing momentum. This makes sense to my personal experiences in group projects, where collaboration and frequent feedback were crucial for successful outcomes.

The resource also highlighted the value of user-centric design. A concept I deeply appreciate. As a programmer so far I feel, it’s easy to focus on technical requirements and overlook user experience. I realized all the projects I have worked on so far have been not user-friendly and you would have to know some competence in code to run them. 

Conclusion

The principles discussed in the resource have given me good exposure to help my understanding of modern software management. By getting the gist of  Agile methodologies, CI/CD, DevOps, and user-centric design in future classes, when we start talking about them, I will already be able to follow along and have a little foundation. 

Sources:

https://www.hakunamatatatech.com/our-resources/blog/principles-of-modern-software-management/

From the blog CS@Worcester – Zacharys Computer Science Blog by Zachary Kimball and used with permission of the author. All other rights reserved by the author.

The other day I read a blog post/article that outlines the software development process that was emphasizing the key steps such as, requirement analysis, planning, design, implementation, testing, and maintenance. The post goes deeper into each step and also gives you tips on the steps. It also highlights the significance of clear goals and choosing the right development methodologies, and ongoing quality assurances. I selected this blog/article because this was something we talked about in class the other day and it looked interesting to read about. Not knowing that there was way more to the software development process than those steps that have to be taken. In the article there are some things that I found very interesting in the reading, talking about how they cant stress enough that team collaboration and adaptability should be changing throughout the project’s process/lifecycle. Another thing that also had me interested was it talks about the maintenance cycle but it goes deeper and talks about 4 different types of maintenance like corrective maintenance, preventative maintenance, perfective maintenance, adaptive maintenance. Honestly it resonated with me because I thought it was interesting and it made me think about how in the future when I got to the maintenance part of my projects that I’m going to look closely at the type of maintenance I’m going to need at that moment. In the future, I’ll try to foster better team collaboration and remain open to change, which will also improve the overall quality of my work. By applying the insights from this article, I feel more equipped to navigate the complexities of software development, from initial planning to long-term maintenance and enhancement. The post also caused me to reconsider testing’s function—not just as a one-time event, but as a continuous, vital part of the entire process. The long-term viability and dependability of the software are guaranteed by continuous testing. I intend to adopt this repeated testing and feedback mentality going forward because it is important for lowering errors and raising overall quality. Additionally, the emphasis on teamwork and open communication brought attention to the importance of these qualities, which I think will be crucial to the success of any project I work on. I also came to understand that, compared to just going on to the next phase, each one offers a chance to make improvements to the final product. By putting these ideas into practice, I will be able to improve my results going forward and maintain my ability to adapt and provide answers that are consistently of the best possible quality.

https://relevant.software/blog/software-development-process/

From the blog CS@Worcester – A Bostonians Blogs by Abdulhafeedh Sotunbo and used with permission of the author. All other rights reserved by the author.

This week I have taken a look at Bob Ducharme, a senior technical writer at Ontotext, a company that produces data management software, and his personal blog. In this entry, Ducharme details various points surrounding the importance of documentation standards, or guidelines for efficient documentation, and provides a brief dive into documenting Application Programming Interfaces. His main stance on documentation is that it should always align with the specific company’s product vision, this is to ensure that user ease is prioritized especially when it comes to understanding a product, as good documentation can be a great form of marketing. Ducharme then provides tools and tips for documentation, Jupyter Notebook is recommended as well as keeping things short, readable, and proportional, especially code samples. He also warns to avoid documentation presented in multiple top-level sections. This is a common practice amongst companies nowadays but it makes for a more difficult navigation experience for users. Ducharme then went on to write about the documentation of APIs. His top points were that documentation is critical when working with some programming languages due to their functions and libraries that lend insight into a product’s internal workings. He provides more advice for documentation tools as he recommends Swagger, Sphinx, Pydoc, and Doxygen because they can take the comments found in the code and turn them into formatted documentation with the aid of a tech writer clarifying the necessary parameters needed for documentation standards to be met. 

I selected this particular post for many reasons, the first and main reason being that I always appreciate when an author creates a sense of personalness. I find a piece more readable and attention-grasping when it avoids a strict formal tone and has a story-like quality. Ducharme even included a hand-drawn diagram that really added that personal touch. To add to the readability factor, Ducharme formatted his post into bulleted sections, breaking things up more concisely and providing an easier and more engaging read. I also could immediately trust the information I was reading as within the first paragraph Ducharme lies down a line of credibility by mentioning he is an accredited enough figure that he has been asked to be interviewed on podcasts to speak on this specific topic. He is also a senior writer in the field, providing his own experiences from his career. Another huge factor is all of the great advice provided about proper documentation standards and the inclusion of different resources to reach efficient documentation.

I feel Ducharme supplied really important advice on documentation standards that I will take with me into the future and apply myself. I have clear sense of what makes efficient documentation and that complex sectioning is not always necessary and keeping things user-orientated, thus simple and readable is the route to go. Ducharme gave a very thorough description of documenting API, allowing his expertise on that topic to shine through. His explanation was very educational and I definitely see myself using Swagger, Sphinx, Pydoc, or Doxygen for assistance in formatting comments properly. Also in future practice in my career space if working as a developer I will know how to properly work with tech writers who are trying to achieve documentation standards. For example, when providing a type of parameter I will be sure to indicate what the typical high and low values will be and the effects they will have so the tech writer can make the necessary correct alterations. Overall, if looking for a refreshing insight into achieving documentation standards with the inclusion of the best formatting standards and helpful tools to achieve them I would highly recommend giving Bob Ducharme’s blog a read ( https://www.bobdc.com/blog/techwritingadvice/ ).

From the blog CS@Worcester – CS Journal by Alivia Glynn and used with permission of the author. All other rights reserved by the author.