Experienced in building, designing, and maintaining Python backend software. Evidenced by success in projects which were pivotal in allowing companies to launch their software to new customers in new regions while managing internal complexity, ensuring that success is sustained and sustainable. When I'm not making backend software, I'm leveraging DevOps practices to ensure a fast and safe road to production. I have experience using Github Actions, AWS CodePipeline, AWS CodeBuild, Jenkins to enable engineers. I build dashboards in Grafana and AWS Cloudwatch to monitor key performance and health metrics of live systems. Usually found using mature Python libraries and tools; Django, FastAPI, Flask, Pydantic, Black, Ruff, Pipenv. Often found engineering simple, well-tested code using behaviours such as Test Driven Development, Pair / Mob programming, Domain Driven Design, Keep It Simple Stupid (KISS), Extreme Programming (XP). Proficient in AWS technologies such as Lambda, CodePipeline, RDS, EC2, EventBridge, Cloudwatch and management and profile features such as IAM and ParameterStore. Passionate about developer experience and overall efficiency in the development system, using evidence and empiricism to improve throughput (deployments / day) and safety (change failure rate).
My Mentoring Topics
- Software engineering
- Serverless
- AWS
- Early career
- Team dynamics and operation
Phillip didn't receive any reviews yet.
Modern Software Engineering - Doing What Works to Build Better Software Faster
David Farley
Before diving into a detailed summary and analysis of the book "Modern Software Engineering - Doing What Works to Build Better Software Faster" by David Farley, let's first highlight the most important key insights the book offers: - Emphasizing the role of Continuous Delivery: The book discusses the importance of continuous delivery in modern software engineering and highlights how it can improve both productivity and reliability. - Focus on Automation: Farley emphasizes the role of automation in software development, testing, and deployment, arguing that it can reduce human error and increase efficiency. - Importance of Testing: The book explains the necessity of testing at all stages of the software development process to ensure the delivery of quality software. - Value of Feedback: Farley believes in the power of feedback and its importance in improving the software development process. - Role of Culture: The book discusses the significance of a healthy team culture in building successful software. - The Need for Iterative Development: Farley advocates for iterative development and continuous improvement as crucial elements of modern software engineering. - Embracing Change: The book encourages software engineers to embrace change rather than resist it, as it is a natural aspect of the software development process. - Understanding the Business: Farley emphasizes that software engineers must understand the business they are working for, as it can aid in making better decisions about software development. - Pragmatism Over Dogmatism: The book encourages being flexible and pragmatic when it comes to software development methodologies and techniques, rather than sticking to a rigid set of rules. - Decomposition and Modularization: The book talks about breaking down complex systems into smaller, manageable modules to enhance understandability and maintainability. - Learning from Failures: Farley encourages learning from failures and mistakes to improve future software development efforts. Summary and Analysis of the Book "Modern Software Engineering - Doing What Works to Build Better Software Faster" by David Farley is a comprehensive guide to the principles and practices of modern software engineering. Farley, being a pioneer in Continuous Delivery, emphasizes its importance and advocates for its widespread adoption. The book starts by discussing continuous delivery and its role in modern software engineering. Farley presents continuous delivery as a critical practice that ensures the software can be reliably released at any time, thereby increasing both productivity and reliability. This notion aligns with the DevOps philosophy, which is a well-accepted practice in current software development. In line with the concept of continuous delivery, Farley places a significant emphasis on automation. He discusses how automation in software development, testing, and deployment can reduce human error, increase efficiency, and ensure the consistent quality of the software. This perspective coincides with the growing trend of automation in the software industry, where technologies like CI/CD pipelines, automated testing, and configuration management tools are becoming increasingly prevalent. One of the key insights from the book is the importance of testing. Farley argues that testing should be integrated into all stages of the software development process, from requirements gathering to deployment, to ensure the delivery of quality software. This approach is in line with the Test-Driven Development (TDD) and Behavior-Driven Development (BDD) methodologies that are widely advocated in the software industry. Farley also underscores the value of feedback, both from the system and from the team members. He states that feedback is crucial for identifying problems early and making necessary adjustments, thereby improving the software development process. This idea is reminiscent of the Agile principle of regular reflection and adjustment. The book also explores the role of culture in building successful software. Farley stresses the importance of a healthy team culture that promotes collaboration, transparency, and continuous learning. This perspective is in line with the cultural component of DevOps, which emphasizes the significance of culture in successful software delivery. Another critical insight from the book is the need for iterative development. Farley suggests that software development should be viewed as a process of continuous improvement, with regular iterations and incremental changes. This view aligns with the Agile methodology, which advocates for iterative development and incremental delivery. Farley encourages software engineers to embrace change, stating that it is a natural part of the software development process. He argues that by embracing change, software engineers can ensure that the software remains relevant and meets the changing needs of the users. The book also emphasizes the necessity for software engineers to understand the business they are working for. Farley argues that a deep understanding of the business can aid in making better decisions about software development, as it allows engineers to align the software with the business objectives. In terms of methodologies and techniques, Farley encourages pragmatism over dogmatism. He advises being flexible and pragmatic when it comes to software development methodologies and techniques, rather than sticking to a rigid set of rules. This advice is particularly relevant in the current software industry, where there is a wide range of methodologies and techniques available, and the best approach often depends on the specific context and needs of the project. The book talks about decomposition and modularization as a strategy to manage complexity in software systems. Farley discusses how breaking down complex systems into smaller, manageable modules enhances understandability and maintainability. This idea is consistent with the principles of microservices architecture, which advocates for decomposing monolithic systems into smaller, independently deployable services. Lastly, Farley encourages learning from failures and mistakes to improve future software development efforts. He argues that failures provide valuable lessons and insights that can be used to enhance the software development process. In conclusion, "Modern Software Engineering - Doing What Works to Build Better Software Faster" offers a wealth of insights into the principles and practices of modern software engineering. The book is grounded in Farley's extensive experience and provides practical advice that can be readily applied in the field. Whether you are a software engineer, a team leader, or a business stakeholder, this book is a valuable resource that can help you build better software faster.
ViewAccelerate - The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations
Nicole Forsgren PhD, Jez Humble, Gene Kim
Key Facts or Insights from the book Lean Software Development and DevOps practices have a direct impact on IT performance and organizational performance. Building quality into products is more efficient than inspecting at the end of production. High-performing organizations decisively outperform their lower-performing peers. They have more frequent code deployments, faster lead time from commit to deploy, faster time to recover from downtime, and lower change failure rate. The right culture is a critical aspect of IT performance. The book introduces the concept of a generative culture, which emphasizes learning and continuous improvement. Automation is a key factor in improving both deployment frequency and lead time for changes. Continuous delivery and lean management practices drive higher IT and organizational performance. Measurement and monitoring are crucial for improving performance. The book introduces four key metrics that matter for DevOps: lead time, deployment frequency, mean time to restore (MTTR), and change fail percentage. Transformational leadership is essential for achieving high performance in technology organizations. DevOps is not just for startups or tech companies - it can generate significant value in large, complex organizations. High performers make use of loosely coupled architectures and teams, enabling them to make changes more effectively and efficiently. Investing in DevOps capabilities can deliver powerful competitive advantage. Summary and Analysis The book, co-authored by Nicole Forsgren PhD, Jez Humble, and Gene Kim, is an invaluable resource for understanding the principles and practices that drive high performance in technology organizations. It presents a rigorous, data-driven argument for why DevOps and Lean principles matter, backed by four years of research and data from more than 2000 data points. Lean Software Development and DevOps are presented as vital methodologies for any organization that seeks to improve its performance and competitiveness through software. The authors argue that software development should not be seen as a cost center but as a strategic capability that can provide a competitive advantage. One of the key insights from the book is the importance of building quality into products rather than inspecting at the end of production. This is a core principle of Lean Manufacturing, applied here to software development. The authors argue that this approach reduces waste, speeds up delivery, and leads to better products. The book makes a compelling case that high-performing organizations significantly outperform their lower-performing peers, with more frequent code deployments, faster lead times, lower change failure rates, and quicker recovery from downtime. These performance advantages translate to organizational benefits, such as increased profitability, market share, and customer satisfaction. A central theme is the role of culture in IT performance. The authors introduce the concept of a generative culture, which values learning and continuous improvement. Such cultures foster innovation, collaboration, and high performance. Automation is another key factor in improving performance. The authors demonstrate how automation in testing, deployment, and other areas can improve deployment frequency and lead time for changes. The book emphasizes the importance of continuous delivery and lean management practices. Continuous delivery enables organizations to get changes of all types into production safely and quickly in a sustainable way. Lean management practices, such as visual management and a culture of continuous improvement, contribute to higher IT and organizational performance. Measurement and monitoring are identified as crucial for improving performance. The authors propose four key metrics that matter for DevOps: lead time, deployment frequency, mean time to restore (MTTR), and change fail percentage. By focusing on these four metrics, organizations can drive improvements in their DevOps practices. The book stresses the importance of transformational leadership in achieving high performance in technology organizations. Leaders must inspire and motivate their teams, promote a clear vision, intellectually stimulate their followers, and provide supportive leadership. Finally, the authors dispel the myth that DevOps is only for startups or tech companies. They argue that DevOps can generate significant value in large, complex organizations. They also point out the benefits of loosely coupled architectures and teams, which enable organizations to make changes more effectively and efficiently. In conclusion, the book provides a comprehensive and evidence-based guide to the principles and practices that drive high performance in technology organizations. It makes a compelling case that investing in DevOps capabilities can deliver powerful competitive advantage. The book's insights and recommendations align well with my own experience and observations as a professor dealing with these topics. I believe it is an essential read for anyone involved in software development or IT operations.
ViewThe DevOps Handbook - How to Create World-Class Agility, Reliability, & Security in Technology Organizations
Gene Kim, Jez Humble, Patrick Debois, John Willis, Nicole Forsgren
The DevOps Handbook: Key Insights DevOps is not just a technical approach, but a cultural shift that aims to bring together the traditionally siloed teams of development and operations. Automation is a cornerstone of DevOps – it accelerates the delivery process, reduces errors and frees up human resources for more value-adding tasks. Continuous Integration and Continuous Delivery (CI/CD) are vital practices in DevOps for maintaining high-quality code and rapid, reliable releases. Measurement and monitoring are essential to understand how changes affect system performance and user experience. DevOps requires shared responsibility and accountability, fostering a blameless culture where learning from failures and mistakes is encouraged. Security should be integrated into the DevOps process from the beginning, not added as an afterthought – a concept often referred to as "DevSecOps". DevOps is about continuous learning and improvement, requiring organizations to be adaptable and resilient in the face of change. Lean principles play a significant role in DevOps, helping to reduce waste, increase efficiency and improve the overall value stream. DevOps success requires leadership support, as it involves significant changes to processes, tools and culture. DevOps is a journey, not a destination, and organizations should expect to continuously evolve their practices and tools to meet changing needs and challenges. An In-depth Analysis of The DevOps Handbook The DevOps Handbook is not just a guide about implementing DevOps practices. It is a comprehensive playbook that bridges the gap between theory and practice, providing actionable insights into creating world-class agility, reliability, and security in technology organizations. At the heart of DevOps is the cultural shift. This shift involves breaking down the silos between the development and operations teams. It encourages collaboration, shared responsibility, and accountability. It fosters a blameless culture where learning from failures is encouraged rather than penalized. This cultural shift is fundamental to the success of DevOps, as it promotes an environment of continuous learning and improvement. The authors emphasize the pivotal role of automation in the DevOps model. Automation not only accelerates the delivery process but also reduces the margin for human error. It frees up human resources, allowing them to focus on more value-adding tasks. This is closely tied with the principles of Lean thinking, which aim to maximize customer value while minimizing waste. It's about designing work to reduce waste and improve efficiency, thereby enhancing the overall value stream. The book also highlights the importance of Continuous Integration and Continuous Delivery (CI/CD) in maintaining high-quality code and enabling rapid, reliable releases. CI/CD pipelines automate the stages of code production, from integration and testing to delivery and deployment, creating a consistent and efficient workflow. Measurement and monitoring are another key aspect discussed in the book. These are critical to understand the impact of changes on system performance and user experience. They provide feedback that informs decision-making and helps identify areas for improvement. One of the significant insights from the book is the integration of security into the DevOps process. The authors advocate for "DevSecOps" – the notion that security should be considered from the outset, not added as an afterthought. This approach ensures that security is built into every part of the software delivery lifecycle. Finally, the authors stress that DevOps is not a one-size-fits-all model or a destination to be reached. Instead, it's a journey of continuous evolution and adaptation. They underscore the need for leadership support, as implementing DevOps involves significant changes to processes, tools, and culture. The DevOps Handbook, therefore, offers a comprehensive roadmap for organizations looking to embark on the DevOps journey. It provides the necessary knowledge and tools to implement the practices and principles of DevOps effectively. It is a valuable resource for any organization seeking to enhance its agility, reliability, and security in today's fast-paced digital world.
ViewDomain-driven Design - Tackling Complexity in the Heart of Software
Eric Evans, Eric J. Evans
Key Facts and Insights from the Book Domain-Driven Design (DDD) is a software development approach that focuses on the core domain and domain logic, rather than the technology used in implementing systems. DDD uses a model-driven design where the model encapsulates complex business rules and processes. This model becomes an essential part of the language used by both the team and the business experts. Ubiquitous Language is a key concept in DDD, a common language that is developed by the team for describing system functionalities. It bridges the gap between the technical team and the business experts. DDD promotes Bounded Contexts, which define the boundaries within which a model is applicable and where the Ubiquitous Language is valid. DDD uses strategic design tools like Context Mapping and Distillation to manage complexities and focus on the core domain. Entities, Value Objects, Aggregates, and Services are fundamental building blocks in DDD to model the domain. DDD advocates for a collaborative and iterative process involving domain experts, which leads to a deep understanding of the domain and a model that accurately reflects it. Repositories are used in DDD to provide an illusion of a collection of all objects of a certain type. An In-Depth Analysis of the Book In his book, Eric Evans provides a comprehensive guide to tackling complex software projects using Domain-Driven Design (DDD). The book is divided into four major parts: Putting the Domain Model to Work, The Building Blocks of a Model-Driven Design, Refactoring Toward Deeper Insight, and Strategic Design. In Putting the Domain Model to Work, Evans introduces the concept of a Domain Model, an abstraction that represents the knowledge and activities that govern the business domain. He emphasizes the importance of the model being a collaboration between technical and domain experts, and not just a schema for data. The section also introduces the concept of Ubiquitous Language, a common, rigorous language between developers and domain experts. This language, used in diagrams, writing, and conversation, reduces misunderstandings and improves communication. The Building Blocks of a Model-Driven Design is where Evans lays out the elements used to construct a model: Entities, Value Objects, Services, Modules, Aggregates, and Repositories. Entities are objects defined by their identity rather than their attributes. Value Objects, on the other hand, are described by their attributes and don't have an identity. Services are operations that don't naturally belong to an object, and Repositories provide a way to access Entities and Value Objects. Refactoring Toward Deeper Insight delves into the iterative nature of DDD. It discusses how to incorporate new insights into the model and refine the model to make it reflect the domain with greater clarity and depth. One of the key techniques mentioned here is Model-Driven Design. The last part, Strategic Design, discusses managing the complexity of large systems. It introduces the concept of Bounded Context, which defines the applicability of a model within specific boundaries. Context Mapping is then used to understand the relationship between different bounded contexts. The book also discusses the concept of Distillation, where the most valuable concepts in a model are identified and isolated, to ensure they don't get lost in the complexity. Evans' book provides a comprehensive methodology for tackling complex domains. By focusing on the core domain, modeling it accurately, and continuously refining the model, software developers can create systems that provide real business value and are adaptable to changing business needs. Domain-Driven Design is not just a technical approach, but a way of thinking, a mindset that puts the domain and its complexity at the heart of software development.
ViewClean Code - A Handbook of Agile Software Craftsmanship
Robert C. Martin
Key Insights from Clean Code - A Handbook of Agile Software Craftsmanship The importance of writing clean code and its impact on software maintenance and scalability. The principles of SOLID design: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. How to correctly use comments in code and when to avoid them. The significance of meaningful names for variables, functions, classes, and modules. The concept of functions: how they should be small, do one thing, and do it well. The art of error handling and the importance of throwing meaningful exceptions. The principles of Test Driven Development (TDD) and the importance of writing tests first. The importance of keeping the codebase clean through continuous refactoring. The idea of code smells and how to identify them. How to manage system dependencies to ensure loose coupling. Analysis and Summary of the Book "Clean Code - A Handbook of Agile Software Craftsmanship" is a comprehensive guide that provides a deep dive into the principles and practices of writing clean, readable, and maintainable code. The book is grounded in the author's deep experience and understanding of software development and its challenges. The book opens with an emphasis on the importance of writing clean code. It asserts that code quality is a fundamental aspect of software development that directly impacts the maintenance, scalability, and overall health of software projects. It argues that code is read far more often than it is written, making readability a key quality attribute. The book introduces the SOLID design principles, a set of guidelines for object-oriented design and architecture. These principles aid in the development of software that is easy to manage and maintain, with a focus on avoiding code smells, reducing complexity, and improving readability. Comments are a double-edged sword. While they can provide important context and explanation, the book argues that they are often used as a crutch to justify complex or confusing code. Comments should not replace clear and concise code. Naming conventions are another crucial aspect of clean code. The book explains the importance of choosing meaningful and descriptive names for variables, functions, classes, and modules. Names should convey intent and make the code self-documenting. The book also provides detailed guidance on how to write functions. Functions should be small, do one thing, and do it well. This aligns with the Single Responsibility Principle, one of the SOLID principles. Error handling is another key topic. The book stresses the importance of throwing meaningful exceptions and managing errors in a consistent and predictable manner. It also covers Test Driven Development (TDD), a software development process that promotes writing tests before writing the actual code. TDD helps in ensuring that the code is working as expected and leads to modular, flexible, and bug-free code. The book emphasizes the need for continuous refactoring to keep the codebase clean. Refactoring is not just about rewriting code; it’s about improving the design of existing code while preserving its functionality. Code smells are certain structures in the code that suggest the possibility of a deeper problem. They are indicators of poor design and coding practices that need to be refactored. The book concludes with a discussion on how to manage system dependencies to ensure loose coupling, which makes systems more manageable and less prone to bugs. In summary, "Clean Code - A Handbook of Agile Software Craftsmanship" is a must-read for any serious software developer or engineer. It goes beyond teaching specific techniques or practices, instead instilling a mindset and philosophy towards writing code that is clean, understandable, and maintainable. To master the art of writing clean code, one must not only understand these principles but also incorporate them into their daily coding practice.
View