Talks
Speakers
Events
Topics
Sign in
Home
Talks
Speakers
Events
Topics
Leaderboard
Use
Analytics
Sign in
Suggest modification to this talk
Title
Description
Monoliths Between Microservices by Vladimir Dementyev "Rails applications tend to turn into giant monoliths. Keeping the codebase maintainable usually requires architectural changes. Microservices? A distributed monolith is still a monolith. What about breaking the code into pieces and rebuild a monolithic puzzle out of them? In Rails, we have the right tool for the job: engines. With engines, you can break your application into components—the same way as Rails combines all its parts, which are engines, too. This path is full of snares and pitfalls. Let me be your guide in this journey and share the story of a monolith engine-ification." __________ Vladimir is a mathematician who found his happiness in programming Ruby and Erlang, contributing to open source and being an Evil Martian. Author of AnyCable, TestProf and many yet unknown ukulele melodies.
Date
Summarized using AI?
If this talk's summary was generated by AI, please check this box. A "Summarized using AI" badge will be displayed in the summary tab to indicate that the summary was generated using AI.
Show "Summarized using AI" badge on summary page
Summary
Markdown supported
In the talk "Monoliths Between Microservices" presented at RailsConf 2020, Vladimir Dementyev explores the challenges and strategies associated with maintaining a Rails application as it grows, particularly in managing the transition from monolithic to microservices architectures. ### Key Points Discussed: - **The Nature of Rails Applications**: Rails applications are inherently monolithic, including diverse functionalities like APIs, background jobs, and utilities. This can lead to inefficiencies as the codebase expands. - **The Misconception of Microservices**: A typical approach suggests breaking an application into microservices, which often results in distributed monoliths—still cumbersome and difficult to manage, negating the advantages sought. - **Separation of Concerns**: Emphasizing the importance of logically separating an application into independent components, this separation eases maintenance and improves developer experience. - **Component-Based Monoliths**: Vladimir provides examples of successful modular architectures, including Shopify's approach and others like umbrella projects in Elixir. He highlights that while some models are not directly applicable to Rails, their concepts can be adapted. - **Utilizing Rails Engines**: Engines in Rails allow for the segmentation of code into manageable pieces—much like other modular frameworks. Each engine acts as a mini-application, providing a path to a more organized codebase. - **Case Study - Common and Cocaine Projects**: Vladimir shares insights from his work on these projects, explaining how their architecture evolved into a component-based system using Rails engines. He discusses the initial use of namespaces and the progression towards more isolated and portable code. - **Challenges and Solutions**: Throughout the presentation, he identifies common pitfalls—like dependency management and database migration—and offers intelligent solutions, such as utilizing a shared Gemfile structure to maintain dependencies synchronously across engines. - **Testing and CI Complexity**: The talk also touches on the complexities of testing in a component-based architecture, suggesting methods for isolating tests by engine and managing them effectively within a CI environment. - **Communication Between Components**: To facilitate interaction between engines, Vladimir introduces the idea of event-driven architecture, highlighting their use of publish/subscribe mechanisms for smooth operation between components. ### Conclusion and Takeaways: - Engines provide a solid foundation for building component-based applications in Rails, allowing for better organization and potential future scalability to microservices. - Migrating from monolithic applications requires thoughtful consideration of architecture, dependencies, and isolation techniques. - While the transition presents challenges, with careful planning and the use of engines, developers can create robust applications that are easier to maintain and evolve over time. Vladimir's talk serves as a guide for developers seeking to optimize their Rails applications by understanding and implementing component-based architectures.
Suggest modifications
Cancel
