Software engineer and author Eric Normand discusses the maintainability of code bases, pros and cons of microservices, higher-order functions, challenges of writing a book on rapidly evolving technology, and provides book recommendations on architecture.
Smaller code bases are easier to maintain, and the maintainability of a code base depends on the team of engineers working on it.
Breaking down software into microservices can make individual parts easier to understand and maintain, but it can introduce complexity at the macro level and managing connections between microservices.
Deep dives
Characteristics of Well-Maintained Software
Well-maintained software is often characterized by a smaller code base, which is easier to maintain. Additionally, the team's understanding and shared knowledge of the software's design play a crucial role in its maintainability. Challenges arise when new team members join, and efforts are required to onboard or mentor them. The webinar also discusses the ebb and flow of popularity in software development trends, such as microservices, and the potential complexities that can arise. Habitability is highlighted as an important aspect, emphasizing the need to consider the human side of code development and how it affects the software's maintenance and navigation.
Moving Beyond Microservices
The podcast explores the notion of breaking down software into smaller microservices and the potential challenges that can arise. While breaking down software into small, independent units can make individual parts easier to understand and maintain, a different set of complexities can emerge at a macro level. Managing the connections and interactions between different microservices can introduce additional complexity and difficulties in refactoring and maintaining the overall system. The speaker highlights the importance of finding a balance between the benefits of microservices and the need for maintainability and simplicity in the software architecture.
The Importance of Refactoring and Simplifying Code
The podcast emphasizes the significance of refactoring and simplifying code as a means to improve maintainability. The speaker discusses the benefits of separating actions, calculations, and data within the codebase, allowing for better modularity and ease of understanding. By utilizing functional programming concepts and higher-order functions, code can be abstracted and made more reusable. The speaker also addresses common concerns, such as the potential impact of refactoring on functionality and the importance of maintaining backward compatibility. Overall, the podcast encourages developers to take ownership of the codebase and not be afraid to make necessary changes for improved maintainability.
The Journey of Writing a Software Book
The podcast delves into the speaker's experience of writing a book on software development. It highlights the importance of having a unique perspective or insight that sets the book apart from existing resources and addresses a specific need within the industry. The speaker emphasizes the challenges and time involved in writing a book, including multiple drafts and revisions. The importance of finding the right approach and structure for the book is also discussed. The podcast concludes with the speaker providing an overview of their book, 'Grokking Simplicity,' which aims to teach beginners functional programming in a comprehensive and accessible manner.
Robby has a chat with software engineer, trainer, and author of the book Grokking Simplicity, Eric Normand (he/him/his). As Eric reflects on his experience, the first thought he has of well-maintained software is that it’s like a unicorn (Something you can’t find in real life), but on a more serious note, he emphasizes that smaller code bases are easier to maintain and that the maintainability of a code base is also highly dependent on the team of engineers that are working on it.
Robby and Eric will dive into the pros and cons of microservices in small organizations, why teams need to ensure they know where they're going with the future of their codebase, Eric's book - Grokking Simplicity, the differences within a functional programming language, higher-order functions, Eric’s journey toward authoring a technical book, and the value of engineers being able to get comfortable moving code around in a project without needing to ask for permission first. Tune in and enjoy!