📹 Video Information:
Title: GitHub's tech stack
Duration: 00:58
Overview
The video discusses the current state of a large-scale Ruby on Rails monolithic application, highlighting its continued use alongside the integration of modern technologies and architectures. It emphasizes the evolution from a pure monolith to a more diverse tech stack incorporating various programming languages and platforms.
Main Topics Covered
- Status and scale of the Ruby on Rails monolith
- Integration of modern frontend technologies like React
- Development of microservices and APIs in different languages (Go, .NET)
- Evolution towards modern architecture beyond the monolith
- Use of mobile development technologies (Swift, Kotlin)
- Cloud infrastructure and on-premises data centers
Key Takeaways & Insights
- Despite its age and size, the Ruby on Rails monolith remains central with a large engineering team contributing regularly.
- The monolith has over 2 million git commits and tens of thousands of pull requests, indicating active and extensive development.
- The architecture is evolving by incorporating microservices and APIs written in languages suited to their specific needs, such as Go for high API call volumes.
- Frontend development is shifting towards React, improving UI/UX.
- Mobile applications are developed using native technologies like Swift for iOS and Kotlin for Android.
- Infrastructure strategy includes a hybrid approach with cloud services and physical data centers.
Actionable Strategies
- Maintain and evolve legacy monolithic systems by gradually integrating modern technologies rather than complete rewrites.
- Utilize the right programming languages and frameworks for specific service needs to optimize performance (e.g., Go for API-heavy services).
- Adopt modern frontend frameworks like React to enhance user interfaces.
- Develop native mobile applications using platform-specific languages for better performance and user experience.
- Implement a hybrid cloud strategy combining cloud resources with on-premises infrastructure for flexibility and control.
Specific Details & Examples
- The monolithic Ruby on Rails application has about 700 engineers contributing at different times.
- Over 2 million git commits and tens of thousands of pull requests have been made into the monolith.
- The copilot API is implemented in Go, designed to handle many API calls for inference.
- Transitioning legacy .NET codebases towards more modern architecture.
- Mobile apps use Swift (iOS) and Kotlin (Android).
- Cloud infrastructure is complemented by commercial data centers using physical metal servers.
Warnings & Common Mistakes
- While not explicitly stated, the implication is that abandoning large monolithic systems entirely might not be necessary or practical.
- A common mistake might be trying to rewrite everything at once instead of evolving the architecture incrementally.
- Managing a large engineering team contributing to a single monolith requires careful coordination and tooling to handle the volume of commits and pull requests.
Resources & Next Steps
- The video references future posts or content that will discuss the transition beyond the monolith in more detail.
- Encourages exploration of microservices architecture and modern frontend frameworks.
- Suggests monitoring and managing large-scale codebases with robust version control and code review processes.