Category Archives: CS-343

Inheritance Problems

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.

Navigating the Upgrade of Outdated Codebases: Insights from Increment

In the world of software development, maintaining and upgrading outdated codebases is a challenge. That’s the reason why I chose this blog post titled “Ask an Expert: Upgrade Outdated Codebase” by the Increment team. Given that this topic directly relates to when class CS348 did an gitpod assignment on software maintenance. I’ve seen many other peers recommend this article as it offers expert advice on how to approach and successfully execute upgrades to aging codebases, ensuring they remain functional and relevant. When you’re faced with these questions, should you make the change, when should you make the change, finally how should you make the change. 

The Increment blog post provides 3 optional & practical strategies for modernizing outdated codebases. 1. A Big Bang Rewrite (changing the codebase from scratch and cutting over all users in a single conversion). But of course, this has its cons, such as being time-consuming and not seeing the process unless it’s all finished. 2. Tack the New onto the Old. The second option is to add new features built with new technology to the existing codebase. However, it’s not like you can just add in a new feature with the old and not touch up the old feature at all.  Outdated features are outdated for a reason, there has to be a balance. 3. A Hybrid Approach. Why choose one, when you can do both? Rewriting your entire codebase is a drastic and often un-recommended move. Adding new features to an old codebase is usually more manageable but can lead to serious issues. Therefore, finding the in-between. This option requires changing out the whole of your old code. But unlike the first option, the rewrite should be spread out over a period of time to minimize technical debt and financial cost. However, all these solutions have side effects, including this one. While you are updating, the technology could continue to advance and you’re left trying to catch up all over again or the specifics/goal changing as you are.

I really appreciate how the creator goes about explain their reasoning. I personally follow the motto: if it isn’t broken, don’t change it. But the way the blog presents actionable advice from industry experts, which is crucial for understanding the best practices in managing and modernizing legacy systems. Made me shift my thoughts a little. Change it before it becomes broken. As quoted from the blog, “it’s probably your last chance to fix the technology before it becomes irreparably broken.” 

Given that this topic directly relates to our course material on software maintenance and evolution, the insights provided are both relevant and timely. One key takeaway from the article is the importance of documenting the existing codebase before initiating any upgrades. Maybe even make another copy, it would be terrible to find out your “updates” ended up making things worse than before you decided to change it. This is definitely something I can expect to apply to future practices. 

I have learned a lot from this blog and for further reading, you can access the original blog post here.

From the blog SoftwareDiary by Oanh Nguyen and used with permission of the author. All other rights reserved by the author.

Welcome to Software Construction, Des & Architecture blog.

In this blog will be talking about the aspects of software construction, design and architecture aspects.

When building software, three important aspects to consider are construction, design, and architecture. Construction is about writing the actual code that makes the software work. It’s like putting together the pieces of a puzzle to ensure everything fits and functions correctly. Design is like planning the layout of a house before you start building. It involves figuring out how different parts of the software will work together, making sure everything is organized and easy to use.

Architecture is the big-picture plan for the software, similar to designing the overall structure of a building. It decides how all the different pieces fit together and interact with each other. Good architecture ensures the software can handle changes and grow over time without falling apart. By focusing on construction, design, and architecture, developers can create software that’s not only functional but also easy to maintain and expand in the future.

From the blog Discoveries in CS world by mgl1990 and used with permission of the author. All other rights reserved by the author.

Welcome To CS-343

Hi welcome to my first blog post for CS-343.

From the blog CS@Worcester – Code Craft by Kyle Tucker and used with permission of the author. All other rights reserved by the author.

Starting the year off!

Welcome to my first blog post! My name is Andi Cuni and I am a senior completing my undergraduate CS degree. Starting my journey blogging with a background in computer science and software development, I am excited for this transition, and I plan to share everything that comes along my experiences to see if others relate as well!

From the blog CS@Worcester – A Day in the Life as a CS Blogger by andicuni and used with permission of the author. All other rights reserved by the author.

Initial Post

This blog will be about my progression and learning I do with the material used within the class and how I use it in class projects, as well as how I use the material with my own personal projects.

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

First blog for CS-343

This is my first blog for CS-343. Feel free to follow my journey.

From the blog CS@Worcester – Live Laugh Code by Shamarah Ramirez and used with permission of the author. All other rights reserved by the author.

Hello World!

September 7, 2024

This is the first blog post on my website. I will be documenting my computer science journey as well as interesting new developments in the tech world.

From the blog CS@Worcester – The Science of Computation by Adam Jacher and used with permission of the author. All other rights reserved by the author.

Introduction Post for CS343

Hello, this is my introductory post for CS343. Feel free to check back every now and then to see what I blog about in this course.

From the blog CS@Worcester – Computer Science Through a Senior by Winston Luu and used with permission of the author. All other rights reserved by the author.

Intro: Software Construction, Design and Architecture

This post serves as the starting point of a series of blog post that will be used to dive deeper into the topics of Software Construction, Design, and Architecture.

-EA

,

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