PDF Summary:Modern Software Engineering, by David Farley

Modern software development requires a fundamentally different approach—one rooted in engineering principles. In Modern Software Engineering, David Farley explains how focusing on deepening your understanding and managing complexity can revolutionize the way software is created.

Farley argues that building software through small, evolutionary enhancements, embracing continuous feedback loops, and adopting a scientific mindset lead to better software quality. He also details strategies for handling complex systems through modular design, clear abstractions, and loosely coupled components—ultimately advocating for an approach that values testability and incremental delivery over rigid processes.

(continued)...

Furthermore, Farley emphasizes the need to differentiate between the complexity inherent in the problem itself and that which emerges as a result of computational constraints. By intentionally isolating these elements, we can create software that focuses on resolving the core problem rather than dealing with the intricacies of storing data, managing concurrent processes, and adhering to common communication standards.

Practical Tips

• You can visualize software structure by creating a modular art piece. Start by choosing a complex image and breaking it down into distinct sections, each representing a different function or module. As you piece it together, think about how each section interacts with the others, mirroring the interplay of software components.
• When planning your weekly meals, think of each meal as a module. Create a mix-and-match system with a set of proteins, vegetables, and grains that can be combined in different ways. This approach allows for variety without the need to plan entirely unique meals every day, saving time and reducing food waste.
• When working on group projects, volunteer to be the point person for one aspect, such as research or presentation design. By taking ownership of a single element, you contribute more effectively and help the team avoid overlap and confusion. This also allows you to develop expertise in that area, which can be beneficial for future projects.
• Try reorganizing your computer's file system to reflect segregated components. Create separate folders for different types of files (documents, images, videos), establish clear naming conventions (like date or topic), and set up notifications for when disk space is low. This practice can give you a sense of how segregation can lead to improved organization and maintenance in digital environments.
• Develop a personal resource allocation plan to ensure your most important projects have what they need to succeed. Create a simple spreadsheet where you track the time, money, and effort you're investing in each project. Adjust your allocations weekly based on progress and needs, similar to how a gardener would water plants more during a drought.
• Develop a game with friends or family where you present each other with various scenarios and collectively decide if they represent a complex problem or a computational constraint. For example, one scenario could be planning a trip with a limited budget (complex problem), while another could be calculating the most fuel-efficient route (computational constraint). This social activity not only makes the differentiation process more engaging but also allows you to benefit from different perspectives, enhancing your ability to distinguish between the two types of problems.
• You can use a problem-solving journal to break down complex issues into their core elements. Start by writing down a problem you're facing in detail. Then, strip away all the technical aspects and focus on the underlying issue. For example, if you're struggling with time management, instead of getting bogged down by the specifics of your daily schedule, identify the core problem, such as a tendency to overcommit or difficulty in prioritizing tasks.

Employing methods that obscure specifics and abstract ideas to manage how software components are seen and how they interact.

The author emphasizes the importance of simplifying details and minimizing complexities to create software systems that are simultaneously flexible and easy to maintain. He combines these principles, underscoring their combined significance in creating clear demarcations within the software that shield its internal mechanisms and diminish the interconnections between its various elements.

Farley suggests that by utilizing strategic simplification, we can increase our software's adaptability, making it easier to evolve and modify while reducing the chances of unexpected results. He underscores the importance of choosing appropriate conceptual models that accurately encapsulate the essence of the issue while excluding unnecessary information. He warns of the danger in creating abstractions which unintentionally expose their inherent complexities, thereby breaking the illusion of simplicity.

The author delves deeper into abstraction, drawing parallels with familiar computing concepts such as "unformatted text" and "data storage units." The seemingly simple concepts are actually sophisticated abstractions that have greatly advanced computing by hiding complexities and fostering interoperability.

Practical Tips

• Use a compartmentalization strategy for your budget to better manage finances. Create separate bank accounts or budget categories for different spending areas, like bills, groceries, entertainment, and savings. By treating each category as an independent module, you can adjust spending in one area without impacting the others, making it easier to adapt to financial changes and maintain control over your budget.
• Develop a habit of drawing simple diagrams that capture the essence of a problem. When faced with a complex situation, try to sketch out the main components and their interactions on a piece of paper. This visual approach can help you see which parts are essential and which are extraneous. For instance, if you're planning a home renovation, draw the rooms that will be affected and the flow of movement, rather than every architectural detail.
• You can simplify your communication by using analogies from everyday life when explaining complex ideas. When you're trying to explain a technical or complex concept to someone, think of an everyday situation that mirrors the structure or function of what you're trying to explain. For example, if you're explaining how a computer processes information, you might compare it to a busy kitchen where orders (inputs) are processed and meals (outputs) are prepared and delivered.
• Create a personal "data storage unit" for important information. Use a spreadsheet to track and manage key personal data, such as subscription services, warranty expiration dates, or household maintenance schedules. This centralizes your data, making it easier to access and update, and it abstracts away the need to remember where everything is stored.

Orchestrating the interactions between software elements to reduce the impact of changes and support continuous enhancement.

Farley discusses the perils of excessive coupling. He recognizes that while certain system interdependencies cannot be avoided, it is crucial to minimize them to preserve agility, enable effective growth, and ensure the system's maintenance remains manageable. He underscores the different types of interconnectedness, such as operational, developmental, semantic, functional, and incidental, and delves into strategies for mitigating their effects.

Farley disputes the common notion that minimal code is invariably superior, illustrating that in order to reduce the reliance among components, it often requires the introduction of additional abstraction layers and more indirect pathways, potentially leading to an initial increase in the amount of code produced. The author argues that the extra work is justified because it results in systems that can be more easily adapted and have the capacity for evolution.

He also delves into finding equilibrium between reducing repetition in a single element and the possible disadvantages of strictly conforming to this concept when it comes to services or modules that are intended to function autonomously. He advises applying the DRY principle judiciously and within defined boundaries to avoid imposing unnecessary constraints and creating excessive interconnections.

David Farley examines the reduction of interdependencies in systems that are geographically dispersed through the use of asynchronous communication. David Farley examines the consequences of non-synchronous communication processes, which often result in fragile and complex systems due to poor abstractions; he promotes communication structures that allow for delayed responses, which, although demanding more upfront effort in planning, typically result in systems that are stronger and more adaptable for future growth.

Context

• Reducing interdependencies helps manage technical debt, which refers to the future cost of rework caused by choosing an easy solution now instead of a better approach that would take longer. By minimizing dependencies, the system remains cleaner and easier to refactor.
• In software engineering, interconnectedness refers to how different parts of a system depend on each other. This can include how data flows between components, how changes in one part affect others, and how different modules or services interact. Understanding these connections is crucial for designing systems that are flexible and maintainable.
• Introducing additional layers can sometimes impact system performance due to increased overhead. However, the benefits in terms of flexibility and maintainability often outweigh these costs, especially in large-scale systems.
• While minimal code can reduce complexity, it can also lead to tightly coupled systems where changes in one part necessitate changes in others. Introducing abstraction layers can initially increase code volume but ultimately enhance maintainability by isolating changes.
• The DRY (Don't Repeat Yourself) principle is a software development practice aimed at reducing repetition of information or code. It encourages the use of abstractions to consolidate repeated logic, which can simplify maintenance and updates.
• This refers to communication methods where the sender and receiver do not need to interact with the system at the same time. Examples include email, message queues, and certain types of APIs. This can help systems remain responsive and decoupled.
• Delayed responses are a feature of asynchronous communication, where systems do not wait for an immediate reply. This approach can improve scalability and resilience by decoupling components, allowing them to operate independently and handle failures more gracefully.

Prioritizing the development of software that can be easily tested leads to quicker feedback and yields code that is simpler to maintain and of superior quality.

Farley emphasizes the importance of developing code that prioritizes testability from the beginning, highlighting that this strategy is crucial for improving code quality, raising its architectural integrity, and guaranteeing that the system can be maintained effectively over time. He maintains that code designed with effective testing in mind typically exhibits features like a modular setup, components with a clear focus, clearly assigned responsibilities, detail encapsulation, and appropriate linkages.

Farley emphasizes the necessity of setting clear metrics and controlling variables to ensure a reliable and precise evaluation of how well a system functions, which is crucial for the development of systems designed with testability as a priority. He advocates for the integration of Test-Driven Development (TDD), highlighting its effectiveness in improving software testability and underscoring its influence on improving design standards by encouraging developers to focus on the system's goals before immersing themselves in the details of its creation.

He explores the challenges of creating a system that is testable, particularly when it involves interactions with external components such as hardware, software from other vendors, or internet-based applications, which can introduce complexity and possible unpredictability. David Farley advocates for the integration of intermediary layers to distinguish the core functions of the system from the specific intricacies associated with these dependencies.

Other Perspectives

• Quicker feedback does not necessarily equate to better software if the feedback is not acted upon effectively; the quality of the response to feedback is as important as the speed with which it is received.
• While prioritizing testability can lead to maintainable and high-quality code, it is not the only factor; other aspects such as clear documentation, robust development processes, and continuous integration and deployment can also significantly contribute to code quality and maintainability.
• There are scenarios, particularly in innovative or research-driven development, where the emphasis on testability might stifle creativity or hinder the exploration of novel solutions that are not immediately compatible with existing testing frameworks or methodologies.
• Assigned responsibilities can result in rigid boundaries between components, which can hinder the ability to refactor or reorganize code when the system needs to evolve.
• Relying solely on controlled variables can miss out on stochastic or environmental factors that could affect system functionality in unpredictable ways.
• TDD requires a significant investment in time and resources upfront, which can be a barrier for tight-budget or fast-paced projects.
• Overemphasis on TDD might lead to over-engineering, where the codebase becomes cluttered with tests for trivial functionality that does not significantly impact the system's goals.
• The use of service virtualization can provide stable, controllable test environments that emulate the behavior of external components, reducing the unpredictability in testing.
• It can be difficult to test the intermediary layers themselves thoroughly, which might introduce new bugs or vulnerabilities into the system.

Tools and methods that support an approach centered on foundational engineering concepts.

This section delves into specific methods and tools designed to improve the approach focused on process orientation in software development. These tools signify a significant shift in our approach and practices concerning the creation and refinement of software.

Emphasizing the incorporation of testing considerations during the design phase.

David Farley emphasizes the significance of integrating testability into the foundational design decisions. Improving code quality is crucial because it molds and steers the evolution of our software systems.

Developing a software architecture that prioritizes straightforward monitoring and control of variables.

Farley describes how the ability to test software effectively depends on the creation of distinct points within the code that allow for precise measurement. Carefully positioning monitoring instruments enables us to evaluate the system's performance while maintaining its structural soundness. Designing an architecture that supports testing requires the incorporation of specific junctures that allow for the straightforward injection of test data, initiation of particular functions, and observation of results.

The principle applies broadly, encompassing everything from individual functions and methods to the entire architecture of the systems. The use of dependency injection along with clearly established interfaces lays the groundwork for the facilitation of automated testing. Creating a simulation for interaction with external systems and establishing a distinct layer for these exchanges allows for accurate and independent evaluation of each element, devoid of the complexities associated with actual operational environments.

Practical Tips

• You can visualize code behavior by drawing flowcharts that represent the logic and potential measurement points. Start with a simple pen and paper, sketching out the main functions of your code and where inputs and outputs occur. This will help you identify where to insert measurement points without needing advanced tools or technical skills.
• Create a mock project to practice setting up dependency injection and defining clear interfaces. Use a simple idea, like a to-do list application, and focus on how you can apply these principles to make the code more testable. This hands-on experience will solidify your understanding and give you practical skills.
• Create a mock stock portfolio to simulate financial market interactions. Use a stock market simulation app or website to practice buying and selling shares based on current market trends without risking actual money. This hands-on experience can give you a feel for market fluctuations and investment strategies, helping you to understand the financial system's complexities.
• You can dissect complex decisions by creating a visual map that separates each factor. Draw a flowchart when faced with a multifaceted decision, such as choosing a new career path. On this chart, isolate each element like job location, salary, and growth opportunities, and assess them independently to make a more informed choice.

Employing automated checks enables swift verification of assumptions regarding the software's functionality.

The writer underscores the significance of incorporating automated tests to create rapid and efficient feedback systems, essential for a method of software creation that is based on the principles of engineering. He argues that a dependence on manual testing, characterized by its slow pace, high costs, and error-proneness, fails to offer a trustworthy approach for evaluating complex systems.

The author emphasizes the significant advantages of implementing automated testing, which include its ability to quickly and reliably identify regressions and detect issues early in the development process, as well as providing immediate feedback on the effects and quality of changes made to the code.

The author draws a distinction between a testing methodology that focuses on validating the functionality of individual software elements and Test-Driven Development (TDD), where tests serve as operational specifications that steer the development and evolution of the application.

He argues that adopting a design approach driven by testing can significantly speed up the development process and decrease the number of defects, while also resulting in software that is more maintainable and flexible.

Practical Tips

• Create a simple feedback loop for any new automation you implement. After setting up an automated task, monitor its performance and solicit feedback from anyone else affected by the change. For example, if you automate an email sorting process, check in with your colleagues to ensure important messages aren't being misfiled. This helps you verify the functionality of the automation and adjust as needed.
• Create a simple spreadsheet to track and compare the time and resources spent on manual versus automated processes in your personal life. You might track how long it takes to manually update your budget versus using a financial management app. This will give you a clear picture of potential time and cost savings.
• Start a peer review group with colleagues or friends where you regularly exchange work to provide fresh eyes and identify issues early on. This could be as simple as sharing documents over email with a set group of people who then provide feedback within a certain timeframe.
• Create a habit of writing test cases before you start coding a new feature, known as test-driven development (TDD). Even if you're working on a simple script or a personal website, this practice will help you clarify your goals and catch mistakes early, making your work more reliable and efficient.
• Start a personal blog to document your learning journey with TDD, focusing on the challenges and solutions you encounter. Writing about your experiences can solidify your understanding and provide a reference for future projects. For example, after each development session, write a post about the tests you created, what they helped you to uncover, and how they guided your coding process.

The application's designed behavior is authoritatively detailed by the test suite.

Farley encourages developers to think of their automated tests not merely as checks for code correctness, but as a living, evolving representation of the system's intended behavior. David Farley describes the set of tests as a comprehensive array of standards that define the expected functionality of the software.

Adopting this viewpoint leads to a fundamental change in our approach to conducting tests. Craft tests that prioritize clear and concise objectives, concentrating on the desired outcomes rather than the specific methods employed to attain them. The approach encourages employing domain-specific language and behavior-driven development methods to craft tests that can be easily comprehended by stakeholders, regardless of their technical expertise.

Other Perspectives

• Tests typically verify the correctness of the system under known conditions and may not be effective in predicting or capturing real-world usage scenarios and edge cases.
• Tests that do not consider specific methods might miss important edge cases that only occur due to the interaction of particular implementations, potentially leaving significant bugs undiscovered.
• Domain-specific language (DSL) in tests can create a barrier to entry for new developers who are not yet familiar with the domain, potentially slowing down the onboarding process.
• BDD requires a strong collaboration between developers, testers, and business stakeholders, which may not be feasible in all organizational cultures or team structures.
• Stakeholders without technical expertise might not need to understand the intricacies of tests, as their primary concern is often the end product rather than the testing process.

Embracing the core tenet of continuous delivery across the organization.

Farley champions the incorporation of continuous delivery, an all-encompassing approach capable of revolutionizing the entire process by which software is developed. David Farley elucidates that the essence of continuous delivery transcends mere deployment automation, influencing the foundational aspects of how we build software, structure our teams, and shape our organizational culture.

Structuring the software development workflow to produce releasable software on a frequent, ongoing basis

Farley emphasizes the core principle of continuous delivery, which is to keep software ready for deployment at all times. Every change, no matter how small, should be thoroughly verified and tested to ensure that the system is consistently ready for deployment into the production environment.

Embracing this methodology requires a significant shift away from traditional software development practices. The approach of regularly integrating each developer's updates into a common central codebase multiple times daily aids in the swift detection of problems and contributes to the preservation of the system's consistency during its evolution.

Practical Tips

• Set up a basic automated testing framework for any small-scale coding projects you undertake. Even if you're not a seasoned developer, tools like Selenium for web testing offer user-friendly interfaces for creating automated tests. By integrating these tests into your project, you'll ensure that with each change you make, the software remains stable and deployment-ready.
• You can experiment with agile methodologies by starting a small project at home, like organizing a personal event or redecorating a room. Break the project into small, manageable tasks, set short-term goals, and adapt your plan based on what you learn each week. This hands-on approach will give you a feel for iterative development and continuous improvement.
• Create a basic manual tracking system using color-coded post-it notes on a shared bulletin board in your workspace. Each developer can take a note of a different color and stick it on the board with details of their update every time they integrate their code. This visual aid helps maintain a clear and current overview of the codebase's evolution for all team members.
• Implement a weekly 'integration meeting' with yourself, using a simple spreadsheet or journal to review the past week's activities, decisions, and outcomes. This self-meeting is a time to reflect on what problems arose, how they were handled, and to plan corrective actions for the following week.
• Develop a habit of regular self-reflection to assess the alignment of your actions with your core values. Set aside time each week to review your activities and decisions. Ask yourself if they are consistent with the principles you want to uphold. This practice can help you make more conscious choices that contribute to a coherent life trajectory.

Creating systems that ensure reliable and steady release procedures by automating the tasks of system deployment and setup.

Farley underscores the significance of automation as a crucial element for ensuring regular software releases. The writer emphasizes the importance of expanding automation beyond mere deployment to include tasks like infrastructure setup, configuration management, and environment preparation. Automation not only reduces the chances of errors and consistency problems but also frees the team of developers from monotonous activities, allowing them to focus on more critical elements of their job, like crafting designs and performing in-depth verifications.

Practical Tips

• Create a personalized automation workflow on your computer or smartphone using IFTTT (If This Then That) or similar services to manage repetitive online tasks. Set up an applet to automatically save email attachments to a designated cloud folder, thus minimizing the risk of losing important documents and maintaining consistency in file storage.
• Consider setting up smart home devices to understand the impact of automation on a small scale. Start with programmable thermostats, smart lights, or home assistants like Google Home or Amazon Echo to automate routine household tasks. This will give you a tangible sense of how automation can save time and effort, which can then be extrapolated to understand its benefits in a development environment.

Enhancing the mechanisms for feedback to facilitate swift cycles of iteration and knowledge acquisition throughout the software development lifecycle.

Continuous Delivery is fundamentally about improving the efficiency of the feedback loops. The writer encourages breaking down work into smaller pieces, incorporating automation into key workflows, and a strong dedication to methodologies driven by testing to greatly improve our capacity for quick learning and adaptation. Organizations have the flexibility to test hypotheses, swiftly validate their ideas, and improve the delivery of value to their customers.

David Farley underscores the importance of tracking the time it takes to progress from an initial idea to the successful deployment of software, highlighting this measure as a key indicator of the effectiveness of a continuous delivery pipeline. Teams dedicated to software development can identify and resolve bottlenecks in their process by continuously monitoring and improving their cycle time, ensuring they receive feedback swiftly and effectively.

Practical Tips

• Create a "learning lab" in your home where you can experiment with new hobbies or skills in short, iterative cycles. For example, if you're learning to paint, set up a space with all the materials you need and commit to creating a small painting every week. After each painting, assess what techniques worked well and what could be improved, then apply those learnings to your next piece.
• Use a timer to break your work into focused intervals with short breaks to review progress. For example, set a timer for 25 minutes of uninterrupted work, followed by a 5-minute break to assess what you've done and plan the next steps. This technique, often known as the Pomodoro Technique, can be adapted to ensure that you're not only working in short bursts but also incorporating immediate feedback loops to refine your approach continuously.
• Use a free or low-cost online service to automate appointment scheduling. Instead of back-and-forth emails to set up meetings, a tool like Calendly can be linked to your calendar to allow others to book slots during your available times. This reduces the lag in confirming meetings and accelerates the feedback loop with clients or colleagues.
• Implement a personal 'one-week sprint' to test out a new habit or personal improvement technique. Choose one small change you want to make, such as waking up earlier or reading more, and commit to it for one week. Track your progress daily and at the end of the week, evaluate if this change has added value to your life. This mimics the rapid iteration cycle businesses use to test new ideas.
• Experiment with time-blocking techniques to allocate specific periods for each phase of your software delivery. For example, you might decide to spend two hours on coding, one hour on testing, and another hour on deployment preparation. After a few iterations, review how closely your actual times match your planned times, and adjust your schedule to improve efficiency.
• Use a free online tool to track the time you spend on specific activities. Pick an activity you suspect is a bottleneck in your day, such as checking emails or social media, and use the tool to log how much time you actually spend on it. After collecting data for a week, analyze the patterns and set specific goals to reduce the time spent on these activities without compromising their effectiveness.

The foundational principles of engineering, in conjunction with the associated practices,

This section expands on the engineering principles previously discussed, emphasizing their importance to various aspects of software development beyond just code and architecture.

Employing stringent standards to assess external technologies and components.

Farley recommends a comprehensive assessment of external elements prior to their incorporation into our system. He argues for prioritizing technologies that excel in facilitating testing, ensuring uncomplicated deployment, delivering swift performance, and skillfully handling various components. This helps ensure that integrating these technologies maintains the robustness of our system without introducing additional complications or constraints.

Practical Tips

• Start a tech journal to document your experiences with different technologies. Note down how each tech solution you use fares in terms of testing, deployment, performance, and handling components. This can be as simple as a spreadsheet or a dedicated notebook where you jot down observations and issues encountered with each tool.
• Opt for modular furniture designs when redecorating your living space to keep adaptability high without complicating your setup. Modular furniture can be reconfigured to suit different needs or spaces without requiring complete overhauls. For instance, invest in a sofa that can be split into chairs or a bed frame that adjusts to different sizes, allowing you to adapt to various situations without additional purchases.

Creating team configurations and developing software architectures that foster autonomy while obscuring complex aspects and reducing mutual reliance.

Farley discusses the importance of separating components, hiding complexities, and reducing the connections between them, underscoring that organizing and managing teams effectively is equally crucial for maintaining agility and promoting steady development. He underscores the importance of fostering autonomous teams that can evolve and make choices on their own, thus diminishing the necessity for extensive collaboration and mutual reliance.

He advocates for aligning teams with bounded contexts, leveraging domain-driven design (DDD) principles to create teams that have a shared understanding of a specific problem domain and can operate independently without needing to constantly synchronize their efforts with other teams.

Practical Tips

• You can use a team charter to establish clear roles and responsibilities without formal training. Start by gathering your team and collaboratively creating a document that outlines each person's role, the team's goals, and how you will communicate. This can be done using a simple shared document online. For example, if you're working on a community project, assign roles like coordinator, treasurer, and outreach manager, and agree on regular check-ins to ensure everyone is on track.
• Encourage team members to rotate leadership roles on different tasks or projects. This can be done by setting up a schedule where each member takes a turn leading a meeting or managing a part of a project. Rotating leadership helps individuals understand different aspects of a project and promotes a sense of shared responsibility.
• You can visualize team alignment by creating a physical map of your organization's bounded contexts. Draw a large map on a poster or whiteboard, labeling different regions as different bounded contexts within your organization. Use colored markers or sticky notes to represent teams and their responsibilities, placing them in the appropriate regions. This visual aid can help you see where teams might overlap or where gaps in responsibility may exist, allowing for better alignment and understanding of each team's domain.

Software creation must inherently integrate human judgment, meticulous examination, and intellectual sharpness.

Software creation is fundamentally propelled by the creativity and persistent hard work of people. The expertise, proficiency, and judgment of the team members ultimately determine a project's success, although the importance of methodologies, tools, and technological aspects should not be underestimated.

He emphasizes the necessity for thoroughness, persistence, and ingenuity in all endeavors, recognizing that even with the existence of comprehensive automation and feedback systems, it is the inventive understanding and deep knowledge of the particular domain that are crucial for creating outstanding software.

Practical Tips

• Pair up with a friend for regular "idea exchange" sessions. Collaboration often sparks creativity, so find a friend interested in software or technology and schedule weekly or bi-weekly meetings to discuss new concepts, challenges, and creative solutions. Even if you're not a software expert, talking through ideas can help you understand different perspectives and inspire innovative thinking.
• Create a judgment matrix for decision-making that your team can use when facing project dilemmas. This tool would consist of a simple spreadsheet with criteria such as risk, benefit, and alignment with project goals. Team members score options based on these criteria, helping to guide more informed and consistent judgments across the team.
• You can enhance your problem-solving skills by practicing with daily puzzles and brain games. Engaging in activities like Sudoku, crosswords, or logic puzzles can sharpen your ingenuity and persistence. For example, try to solve a new type of puzzle each week, gradually increasing the difficulty level to challenge your perseverance and creativity.
• Dive into open-source projects to gain a deeper understanding of software development. By contributing to these projects, you can learn from the codebase and community feedback, which can enhance your knowledge of software design and coding practices. For example, you could select a project that interests you on GitHub, study its code, and attempt to fix bugs or add small features, using the discussions and code reviews to learn from more experienced developers.