Part 1: Discussion List and describe benefits and drawbacks of class re-use. • Justify your answer. • Give detailed examples from your experiences. Part 2: Assignment – Classes and Screens In this assignment, you will update your final project proposal to plan for your project, creating a design that you can use to create your code project. While this is a working document, it is understood things many change between the design and implementation. • What items you will be able to create and how you will create them? • Create a storyboard (graphic) and list of menu and screen items to delineate your proposed user screen(s) and menus. Include a starting list of the classes you believe will be useful to your application. • List and describe any user data inputs and outputs your application will require and produce. • If you will be using data validation as one of your techniques, list and describe the criteria needed for each proposed field. • Using Visual Studio, create sample class implementations. These will be code stubs that provide the basis for the classes you will be using Submit the revised document file and Visual Studio project

Part 1: Discussion

Class re-use refers to the practice of utilizing pre-existing classes in a new software development project, rather than creating new classes from scratch. There are several benefits and drawbacks associated with class re-use.

One of the primary benefits of class re-use is increased efficiency and productivity. By re-using existing classes, developers can save time and effort that would otherwise be spent on creating new classes. This is particularly advantageous when working on large-scale projects with tight deadlines. Re-using classes also promotes code consistency, as developers can rely on well-tested and reliable code that has been used in previous projects.

Another benefit of class re-use is improved maintainability. When a class is re-used across multiple projects, any updates or bug fixes made to that class can benefit all the projects that use it. This reduces the risk of introducing new bugs or inconsistencies when making changes to the codebase. Additionally, if a bug is found in a re-used class, it only needs to be fixed once, rather than in multiple instances across different projects.

However, there are also drawbacks to class re-use that need to be considered. One drawback is the potential for increased complexity. Re-used classes may have dependencies on other classes or libraries, which can make the overall codebase more complex and harder to understand. This can be especially challenging for developers who are new to the project or who are not familiar with the re-used classes.

Another drawback is the potential for code bloat. Re-used classes may contain functionality that is not needed or relevant for the current project. This can increase the size of the codebase and introduce unnecessary overhead. It is important to carefully evaluate the relevance and usefulness of re-used classes to avoid code bloat and maintain a clean and efficient codebase.

In my experience, I have seen both the benefits and drawbacks of class re-use. For example, in a previous project, we were able to re-use a well-designed and thoroughly tested logging class. This saved us a significant amount of time and effort in implementing logging functionality. Additionally, when a bug was found in the logging class, we only needed to fix it once and all our projects benefited from the fix. On the other hand, we also encountered challenges with re-used classes that had complex dependencies, causing confusion and difficulties in understanding and debugging the code. We had to invest extra time in studying and understanding the dependencies before we could effectively work with the re-used classes.

Overall, class re-use can be a powerful tool for improving efficiency and maintainability in software development projects. However, careful consideration and evaluation are necessary to ensure that the benefits outweigh the potential drawbacks. It is important to assess the relevance and usefulness of re-used classes and to manage their dependencies effectively to avoid unnecessary complexity and code bloat.