Confessions of a Used Program Salesman: How to Master Software Reuse
Confessions of a Used Program Salesman free download
If you are a software developer, you have probably heard of the term "software reuse". It is the idea of using existing software components or modules to create new applications, instead of writing everything from scratch. Software reuse can save time, money, and improve quality, but it is not as easy as it sounds. There are many technical and non-technical issues that need to be addressed before reuse can become a reality.
Confessions of a Used Program Salesman free download
One of the pioneers and advocates of software reuse is Will Tracz, who has been writing about this topic since 1983. He is best known for his series of articles called "Confessions of a Used Program Salesman", which were published in IEEE Computer, IEEE Software, and ACM Software Engineering Notes. These articles are humorous and insightful, and they explore the various aspects and challenges of software reuse. In 1995, he published a book based on these articles, titled "Confessions of a Used Program Salesman: Institutionalizing Software Reuse".
In this article, we will give you an overview of what this book is about, why it is relevant for software developers, and how you can download it for free. We will also summarize some of the key lessons that Tracz shares in his book, and highlight some of the benefits of reading it.
Introduction
What is the book about?
The book is a collection of 12 chapters, each based on one of Tracz's articles. The chapters cover topics such as:
The history and evolution of software reuse
The management and organizational issues of reuse
The technical aspects and methods of reuse
The emerging technologies and trends that affect reuse
The cultural and psychological factors that influence reuse
The book is written in a witty and engaging style, with many anecdotes and examples from Tracz's own experience as a software engineer and consultant. He uses the analogy of a used program salesman to illustrate the challenges and opportunities of software reuse. He also provides practical advice and tips on how to implement and institutionalize reuse in different contexts.
Why is it relevant for software developers?
Software reuse is still a relevant and important topic for software developers today, even though the book was published more than 25 years ago. The reasons are:
Software development is becoming more complex and demanding, requiring faster delivery, higher quality, and lower cost.
Software reuse can help achieve these goals by reducing duplication, increasing productivity, and enhancing reliability.
Software reuse can also enable innovation and creativity by allowing developers to focus on the core functionality and value proposition of their applications.
Software reuse can facilitate collaboration and communication among developers by promoting common standards and interfaces.
However, software reuse also poses many challenges that need to be overcome, such as:
Finding and selecting suitable reusable components or modules
Integrating and adapting them to the specific requirements and context of the new application
Managing and maintaining them throughout the software lifecycle
Dealing with legal, ethical, and intellectual property issues
Changing the mindset and culture of the developers and the organization to support reuse
The book provides valuable insights and guidance on how to address these challenges and make reuse work in practice.
How can you download it for free?
The book is out of print, but you can still download it for free from the author's website. Here is the link:
http://www.tracz.net/Confessions.pdf
You can also find other resources related to software reuse on his website, such as:
His articles and presentations
His blog posts and podcasts
His bibliography and links to other sources
You can also contact him directly via email or social media if you have any questions or feedback.
Summary of the book
In this section, we will briefly summarize some of the main lessons that Tracz shares in his book. These are not exhaustive, but they give you a glimpse of what you can learn from reading the book.
Lesson #1: Reuse is a management decision
The first lesson that Tracz emphasizes is that reuse is not just a technical issue, but a management issue. Reuse requires a clear vision, a strong commitment, and a strategic plan from the top management of the organization. It also requires adequate resources, incentives, and support for the developers who are involved in reuse. Without these elements, reuse will not succeed.
Tracz suggests that management should adopt a "reuse program" that defines the goals, scope, methods, roles, responsibilities, and metrics of reuse. He also provides a step-by-step guide on how to create such a program, based on his own experience and best practices.
Lesson #2: The reuse rules of three are true
The second lesson that Tracz highlights is that reuse follows some empirical rules that have been observed by many practitioners. These are called the "reuse rules of three", and they are:
Before you can develop reusable software, you need to have developed it three times.
Before you can reap the benefits of reuse, you need to reuse it at least three times.
Before you can measure the benefits of reuse, you need to have reused it at least three times.
These rules imply that reuse is not a one-time event, but a continuous process that requires iteration, feedback, and improvement. They also imply that reuse has a learning curve and a payback period that need to be considered and managed.
Lesson #3: You need to reuse more than just code
The third lesson that Tracz points out is that code is not the only thing that can be reused in software development. There are many other artifacts and activities that can be reused as well, such as:
Requirements
Designs
Tests
Documentation
Tools
Processes
Standards
Patterns
Frameworks
Components
Services
Data
Knowledge
People
Tracz argues that reusing these artifacts and activities can increase the effectiveness and efficiency of software development. He also discusses how to identify, classify, store, retrieve, and use them in different stages of the software lifecycle.
Lesson #4: The "glue" is the key technology
The fourth lesson that Tracz stresses is that the technology that enables reuse is not the reusable components or modules themselves, but the "glue" that connects them together. The glue is the set of mechanisms and conventions that allow different pieces of software to interoperate and communicate with each other. Examples of glue are:
Data structures and formats
Application programming interfaces (APIs)
Messaging protocols and formats
Middlewares and brokers
Distributed object technologies (e.g., CORBA, COM)
Component technologies (e.g., JavaBeans, ActiveX)
Service-oriented architectures (SOA)
Lesson #5: Reuse requires a change in culture
The fifth and final lesson that Tracz emphasizes is that reuse is not only a technical and managerial issue, but also a cultural and psychological issue. Reuse requires a change in the mindset and behavior of the developers and the organization. It requires a shift from a "not invented here" syndrome to a "proudly found elsewhere" attitude. It also requires a balance between individual creativity and collective collaboration.
Tracz suggests that the culture of reuse can be fostered by creating a supportive environment that encourages and rewards reuse. He also provides some tips on how to overcome the common barriers and resistance to reuse, such as:
Lack of awareness and education
Lack of trust and confidence
Lack of motivation and incentive
Lack of ownership and control
Lack of quality and compatibility
Lack of standards and policies
Benefits of reading the book
Reading the book can provide you with many benefits, such as:
Learning from the author's experience and humor: Tracz has been involved in software reuse for more than 30 years, and he has witnessed its evolution and challenges firsthand. He shares his stories and insights in a humorous and engaging way, making the book enjoyable and easy to read.
Gaining practical insights and tips for software reuse: Tracz provides concrete examples and advice on how to implement and institutionalize software reuse in different contexts. He covers both the technical and non-technical aspects of reuse, and he offers solutions and alternatives for various scenarios.
Avoiding common pitfalls and challenges of reuse: Tracz warns you about the potential problems and risks that you may encounter when trying to reuse software. He helps you avoid them or mitigate them by giving you best practices and guidelines.
Conclusion
Recap of the main points
In this article, we have given you an overview of the book "Confessions of a Used Program Salesman: Institutionalizing Software Reuse" by Will Tracz. We have explained what the book is about, why it is relevant for software developers, and how you can download it for free. We have also summarized some of the key lessons that Tracz shares in his book, and highlighted some of the benefits of reading it.
The book is a valuable resource for anyone who is interested in software reuse, whether you are a beginner or an expert. It will help you understand the concepts, methods, technologies, and issues of software reuse. It will also inspire you to apply software reuse in your own projects and organizations.
Call to action for downloading the book
If you want to learn more about software reuse from one of its pioneers and advocates, we highly recommend that you download the book "Confessions of a Used Program Salesman: Institutionalizing Software Reuse" by Will Tracz. You can get it for free from his website:
http://www.tracz.net/Confessions.pdf
You will not regret it. It will make you laugh, think, and learn. It will also make you a better software developer.
FAQs
Here are some frequently asked questions about the book:
Who is Will Tracz?
Will Tracz is a software engineer, consultant, author, speaker, editor, blogger, podcaster, and professor. He has been working in the software industry since 1977, and he has been involved in software reuse since 1983. He has published more than 100 papers and articles on software engineering topics, especially software reuse. He is also the editor-in-chief of ACM Software Engineering Notes.
What is software reuse?
Software reuse is the idea of using existing software components or modules to create new applications, instead of writing everything from scratch. Software reuse can save time, money, and improve quality, but it also poses many challenges that need to be overcome.
What are some examples of software reuse?
Some examples of software reuse are:
Using libraries or frameworks that provide common functionality or services (e.g., Java, .NET, Spring, Django)
Using components or modules that implement specific features or functions (e.g., GUI widgets, encryption algorithms, database connectors)
Using services or APIs that expose functionality or data over the network (e.g., Google Maps, Twitter, PayPal)
Using patterns or templates that capture design solutions or best practices (e.g., MVC, Singleton, Factory)
Using code generators or tools that automate the creation of software artifacts (e.g., UML, XML, SQL)
What are some benefits of software reuse?
Some benefits of software reuse are:
Reducing duplication, increasing productivity, and enhancing reliability
Enabling innovation and creativity by allowing developers to focus on the core functionality and value proposition of their applications
Facilitating collaboration and communication among developers by promoting common standards and interfaces
What are some challenges of software reuse?
Some challenges of software reuse are:
Finding and selecting suitable reusable components or modules
Integrating and adapting them to the specific requirements and context of the new application
Managing and maintaining them throughout the software lifecycle
Dealing with legal, ethical, and intellectual property issues
Changing the mindset and culture of the developers and the organization to support reuse
71b2f0854b