Modularization - how hard can it be? (Droidcon Berlin)

Recording can be found here: https://youtu.be/opsiSaUS2bg

Modularizing Android codebases is all the hype these days. It can be as simple as moving a few files, and maybe creating a new build config or two along the way, or it can be much more gruelling. At Spotify, it has meant clearing out years and years of tech debt, re-writing APIs, rethinking the architecture and structure of the application and features that goes into it, wrestling with build tools, and then some.

This talk will walk you through the Spotify modularization journey: why we got started, how we went about it, what we have learned through the process, and also why you should be thinking about modularizing your code, if you haven't already started.

Links shared in the presentation:

Instagram: https://atscaleconference.com/videos/app-modularization-and-module-lazy-loading/
Square: https://youtu.be/GesiS2bkTKA
Yelp: https://engineeringblog.yelp.com/2018/06/how-yelp-modularized-the-android-app.html
Soundcloud: http://uk.droidcon.com/skillscasts/10525-modularizing-android-applications
Google: https://youtu.be/tYf9ivnQ0eI
Don't stop believing: https://open.spotify.com/track/4bHsxqR3GMrXTxEPLuK5ue?si=F9TZB4JbSAWrb_ZZzm3kQA

Transcript

1. Modularization How hard can it be? Elin Nilsson @hejelinnilsson
2. Very!
3. It’s complicated
4. Modularization is a hot topic Instagram Square Yelp Soundcloud Google +Nikita/Boris +Ben +Wojtek
5. What I will NOT talk about
6. What I WILL talk about
7. The Spotify Modularization Journey “Don’t stop Believin’ that we can modularize!”
8. Why?
9. History
10. Growing Growing Growing Slowing
11. Let’s modularize!
12. How?
13. How we started Goal - one feature outside of the app
14. How we started Goal - one feature outside of the app Upfront work Tooling Align on basic structure
15. :app :libs :features :common :http :logger :audio :video :artist :search :ui
16. :libs :features :common :http :logger :audio :video :artist :search :ui :app
17. :http :logger :audio :video :artist :search :ui :app :features :common :libs
18. :app :features :common :libs :http :logger :audio :video :artist :search :ui :library :feed :profile :radio :radio :android :uihelp :follow :share :exop :depinj
19. How we started Goal - one feature outside of the app Upfront work Tooling Align on basic structure Pull out everything needed to make that feature compile
20. How we started Goal - one feature outside of the app Upfront work Tooling Align on basic structure Pull out everything needed to make that feature compile Heads up! We ask your forgiveness!
21. Let’s try it!
23. analyzeDependencies(); if (file.hasNoDependencies()) { move(file); } else if (file.hasSimpleDependency()) { breakDependency(file.getCode()); } else if (file.hasComplexDependency()) { boolean successful = refactorOrDependencyInversion(file.getCode()); if (!successful) { addModularizationTODO(“This depends on MainActivity, once that’s moved, revisit”); sobQuietlyInTheCorner(); } }
24. analyzeDependencies(); if (file.hasNoDependencies()) { move(file); } else if (file.hasSimpleDependency()) { breakDependency(file.getCode()); } else if (file.hasComplexDependency()) { boolean successful = refactorOrDependencyInversion(file.getCode()); if (!successful) { addModularizationTODO(“This depends on MainActivity, once that’s moved, revisit”); sobQuietlyInTheCorner(); } }
25. Frictionless Slight friction More friction Massive friction
26. Frictionless Slight friction More friction ... Massive friction
27. analyzeDependencies(); if (file.hasNoDependencies()) { move(file); } else if (file.hasSimpleDependency()) { breakDependency(file.getCode()); } else if (file.hasComplexDependency()) { boolean successful = refactorOrDependencyInversion(file.getCode()); if (!successful) { addModularizationTODO(“This depends on MainActivity, once that’s moved, revisit”); sobQuietlyInTheCorner(); } }
28. (remember the tests!)
29. analyzeDependencies(); if (file.hasNoDependencies()) { move(file); } else if (file.hasSimpleDependency()) { breakDependency(file.getCode()); } else if (file.hasComplexDependency()) { boolean successful = refactorOrDependencyInversion(file.getCode()); if (!successful) { addModularizationTODO(“This depends on MainActivity, once that’s moved, revisit”); sobQuietlyInTheCorner(); } }
30. analyzeDependencies(); if (file.hasNoDependencies()) { move(file); } else if (file.hasSimpleDependency()) { breakDependency(file.getCode()); } else if (file.hasComplexDependency()) { boolean successful = refactorOrDependencyInversion(file.getCode()); if (!successful) { addModularizationTODO(“This depends on MainActivity, once that’s moved, revisit”); sobQuietlyInTheCorner(); } }
31. analyzeDependencies(); if (file.hasNoDependencies()) { move(file); } else if (file.hasSimpleDependency()) { breakDependency(file.getCode()); } else if (file.hasComplexDependency()) { boolean successful = refactorOrDependencyInversion(file.getCode()); if (!successful) { addModularizationTODO(“This depends on MainActivity, once that’s moved, revisit”); sobQuietlyInTheCorner(); } }
32. analyzeDependencies(); if (file.hasNoDependencies()) { move(file); } else if (file.hasSimpleDependency()) { breakDependency(file.getCode()); } else if (file.hasComplexDependency()) { boolean successful = refactorOrDependencyInversion(file.getCode()); if (!successful) { addModularizationTODO(“This depends on MainActivity, once that’s moved, revisit”); sobQuietlyInTheCorner(); } }
33. It takes time. Be patient.
34. Modularizing Feature development
35. “We can’t do xyz outside of the main module”
36. If new code is written as if it was in a module, it will be easier to modularize
37. Best practices
38. Best practices in practice DRY - Removing dead code - increasing reuse
39. Best practices in practice DRY - Removing dead code - increasing reuse Avoid parameter dependencies
40. Best practices in practice DRY - Removing dead code - increasing reuse Avoid parameter dependencies Dependency Injection
41. Best practices in practice DRY - Removing dead code - increasing reuse Avoid parameter dependencies Dependency Injection Structure the code
42. Best practices in practice DRY - Removing dead code - increasing reuse Avoid parameter dependencies Dependency Injection Structure the code Avoiding utility classes and static methods
43. Best practices in practice DRY - Removing dead code - increasing reuse Avoid parameter dependencies Dependency Injection Structure the code Avoiding utility classes and static methods SOLID principles
44. SOLID Single responsibility principle Open/closed principle Liskov substitution principle Interface segregation principle Dependency inversion principle
45. SOLID S - Don’t do a lot of things in one class O - Design the API of the class so that it can be used and extended without being modified L - Don’t let implementations of the same interface behave differently I - Don’t design big interfaces D - Depend on abstractions, not on implementations
46. SOLID S - Don’t do a lot of things in one class O - Design the API of the class so that it serves the consumers’ needs without modifying it L - Don’t let implementations of the same interface behave differently I - Don’t design big interfaces D - Depend on abstractions, not on implementations
47. What have we done?
48. 2015 2016 2017 2018
49. It’s still painful
52. 14500 R-files 25 million LOC
53. Build times
54. Gradle vs Bazel vs Buck
55. What’s the lessons?
56. “It’s hard to see the forests for all the trees”
57. Modularization is a tool
58. Modularization is a chance to tackle tech debt
59. Modularization is a chance to get to know your codebase
60. “Single modules are easier to deal with; there are no complex dependency graphs to account for and some details of how the app is managed, such as how testing is implemented, are simpler” - Yelp
61. “Single modules appear to be easier to deal with; there are no complex dependency graphs to account for and some details of how the app is managed, such as how testing is implemented, are simpler” - Yelp (revised by Elin)
62. The complex dependencies are still there, they’re just hidden
63. Words of wisdom Invest in tooling up front Creating modules Dependency versioning Static analysis
64. (remember the tests!) Words of wisdom Invest in tooling up front Creating modules Dependency versioning Static analysis
65. Words of wisdom Invest in tooling up front Creating modules Dependency versioning Static analysis DON’T CHANGE ANYTHING as you go Avoid rabbit holes
66. Words of wisdom Invest in tooling up front Creating modules Dependency versioning Static analysis DON’T CHANGE ANYTHING as you go Avoid rabbit holes Inventory your app
67. Words of wisdom Invest in tooling up front Creating modules Dependency versioning Static analysis DON’T CHANGE ANYTHING as you go Avoid rabbit holes Inventory your app Collect metrics, graphs are fun!
68. Modularization How hard can it be?
69. Very
70. Software development How hard can it be?
71. Very
72. Very You can make it easy, you can make it hard
73. #OddlySatisfying
74. Thank you! Elin Nilsson @hejelinnilsson