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.

  The ‘Your First Language’ pattern from chapter two consists of the idea that you are just starting out and only have a basic understanding of one or maybe even two languages. The problem which is presented is that you as an apprentice believe that your job depends on being able to produce the same quality of work in a specific language that the others around you can even if they may have more experience using said language or that getting any job will depend on your knowledge of one particular language. Then the solution presented it to decide on a ‘first language’ which you will dedicate to familiarize yourself with and when trying to solve a problem you will use this language and further your understanding of its inner workings. Then if an employer requires you to use a specific language you approach it by taking small steps at first and then exponentially grow your steps as you gain more knowledge in order to efficiently learn another language. This pattern encourages you to seek help from experienced friends in order to quickly progress through a problem as long as you do not grow a reliance on them for all the answers. 

  I have a great appreciation for this pattern as I feel it is something that many students and or apprentices may struggle with. Initial thoughts on a first language can be intimidating and heavily influenced by the schooling you go through if any or even others opinions online if you do not pursue technical training initially. You put a lot of consideration into a choice like this and it is important but this pattern highlights the thought that many people may have that they must fully master a language in order to be ‘employable’ in that said language when realistically even people that are considered to be ‘masters’ of a specific language are still learning. What really matters is that you take the steps in your first language and learn from the experience so that you can adjust the steps to learn other languages in the future as your first language is basically your jumpstart in the world of programming languages.

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

In a nutshell, “The White Belt” encourages us to embrace our ignorance and adopt a beginner’s mindset. It’s like entering a martial arts dojo for the first time – a white belt symbolizes a blank canvas, ready to absorb the knowledge and skills the journey offers.

Summary of The White Belt:

1. Ignorance is Okay: The pattern emphasizes that it’s perfectly fine not to know everything. Acknowledging our ignorance is the first step towards real learning.
2. Focus on Learning: Instead of trying to be a jack-of-all-trades, the pattern advises us to focus on learning one thing well. Mastering a single concept or technology sets the foundation for broader expertise.
3. Practice, Practice, Practice: Hands-on experience is key. Whether it’s coding exercises or real-world applications, practice is the bridge between theory and mastery.
4. Seek Feedback: Actively seek feedback from experienced developers. Constructive criticism is the secret sauce for improvement.
5. Expose Your Ignorance: Don’t be afraid to admit what you don’t know. Being open about your limitations opens the door to learning from others.

My Reaction:

What struck me most about “The White Belt” is its emphasis on humility and curiosity. In a world where the pressure to know everything can be overwhelming, this pattern grants permission to be a novice. It made me reflect on how, as a student entering the vast field of software development, it’s okay not to have all the answers.

The call to focus on learning one thing well was a game-changer for me. In a world filled with shiny new technologies, I now appreciate the value of depth over breadth. It’s like building a strong foundation before constructing the skyscraper of knowledge.

This pattern has reshaped my perspective on learning. It’s not just about accumulating information but immersing oneself in the process. Admitting my ignorance, seeking feedback, and practicing relentlessly are now my guiding principles.

In conclusion, “The White Belt” is not just a pattern; it’s a mindset. It has ignited a spark within me, encouraging me to embrace the journey of learning with open arms and a white belt.

From the blog CS@Worcester – Hieu Tran Blog by Trung Hiếu and used with permission of the author. All other rights reserved by the author.