Enhancing Software Architecture with vFunction: Insights from Amir Rapson
I recently had the pleasure of moderating an incredible tech-talk session with Amir Rapson, CTO and Founder of vFunction. Tech-session was organised TBC Bank from Georgia. We delved deep into the nitty-gritty of architectural observability and its role in tackling technical debt. If you couldn’t join us, here are the highlights and key takeaways from our discussion.
Amir Rapson
Amir Rapson co-founded vFunction and serves as its CTO, where he leads its technology, product and engineering. Prior to founding vFunction in 2017, Amir was a GM and the VP R&D of WatchDox until its acquisition by Blackberry, where Amir served as a VP of R&D. Prior to WatchDox, Amir held R&D positions at CTERA Networks and at SofaWare(Acquired by Check Point). Amir has an MBA from the IDC Herzlia, and a BSc in Physics from Tel-Aviv University.
Understanding Architectural Observability and Technical Debt
Amir kicked off the session by emphasising the importance of architectural observability. It’s not just about keeping an eye on our code; it’s about truly understanding the architecture of our systems. This awareness helps us pinpoint and address technical debt early, keeping our software scalable and resilient.
One of the biggest eye-openers for me was how Amir linked technical debt directly to business outcomes. It’s easy to think of it as just a developer’s problem, but in reality, unchecked technical debt can slow down our engineering velocity and lead to more frequent outages, impacting the bottom line.
Architectural discovery and visualisation
Leverage AI-based architecture discovery and mapping to understand the architectural health of applications. Explore different visualizations and identify the most impactful areas of improvement in minutes.
Dependency mapping
Discover complex and dynamic relationships among classes, transactions, files, beans, synchronization objects, sockets, stored procedures, and other resources highlighting areas for improvement.
Architectural technical debt analysis
Architectural technical debt highlights the compromises made during software design and development that affect the system’s core architecture.
Prioritisation and alerting
Incorporate a prioritized task list into every sprint to fix key technical debt issues, based on your unique goals for the domain, including application scalability, resiliency, engineering velocity and cloud readiness.
Architectural drift monitoring
See what’s changed in your architecture since the last release — which domains were added, what dependencies were introduced — and configure automated alerts for new architectural events like new dependencies, domain changes, and cloud readiness issues.
Remediation and automation
vFunction supports transformations for updated frameworks, automates code extraction for microservices creation, and generates the necessary APIs and client libraries for newly created microservices.
Integration and exporting
Export architectural data and analysis results into any system for any purpose, as well as task lists for use in Jira and Azure DevOps. Simplify deployment in cloud ecosystems via licensing and marketplace integrations.
Refactoring: Beyond Service Extraction
We talked about the common challenge of extracting services from monolithic applications. Amir made it clear that it’s not enough to just pull out services. To do it right, you need to refactor the monolith to improve its internal structure, ensuring that the new services don’t end up with messy dependencies.
This approach to refactoring is crucial for achieving a modular architecture. It’s all about breaking down the monolith in a way that each piece can operate independently without creating a tangled web of dependencies.
vFunction platform
Architecture observability and technical debt management
Tools and Techniques for Better Architecture
Amir shared some fantastic insights on using tools like vFunction in conjunction with SonarQube. The integration of these tools can significantly enhance our ability to manage code quality and architectural dependencies. He explained the importance of combining dynamic and static analysis to get a full picture of our software architecture.
Dynamic analysis helps us understand the real-time interactions and method calls in our applications, while static analysis gives us a snapshot of dependencies and code structure. Using both, we can gain comprehensive insights and make informed decisions about refactoring and improvements.
Boosting Engineering Velocity and Business Confidence
One of the big topics we covered was how technical debt affects engineering velocity. Amir pointed out that exhaustive testing and regression testing due to technical debt can really slow us down. This resonated with me because it’s something many teams struggle with. He shared strategies to balance thorough testing with maintaining high velocity, such as reducing regression testing and improving deployment frequency.
We also discussed regaining business confidence after tackling technical debt. It’s not just about fixing the code; it’s about demonstrating improved reliability and reduced risk to the business. Amir emphasized the importance of showing tangible metrics to the business to rebuild trust and move towards quicker, independent deploys.
Good vs. Bad Architecture
We all know bad architecture when we see it—a complete mesh of services with no clear structure. Amir highlighted the characteristics of good architecture, like having minimal interdependencies and clear separation of concerns. He warned against the pitfalls of creating a service mesh, which can lead to a complex and hard-to-maintain system.
Instead, Amir advocated for layered architectures that maintain modularity and reduce complexity. This way, each layer has a specific role, and dependencies are clear and manageable.
Optimizing Database Interactions
We also touched on database usage and how vFunction can help optimize it. Amir explained how the tool provides insights into whether we should use relational or non-relational databases and when to implement caching strategies. These insights are invaluable for improving database performance and overall application efficiency.
Practical Implementation and Continuous Improvement
Integrating vFunction into the software development lifecycle was another key point. Amir stressed that vFunction should be used continuously to manage technical debt and maintain good architecture. He shared metrics that teams can track, like delivery times, recovery times, and the number of incidents, to measure the success of their efforts.
Final Thoughts
This tech-talk with Amir was a deep dive into the heart of software architecture. It reinforced the idea that managing technical debt and maintaining good architecture are ongoing processes that require continuous effort and the right tools. By integrating solutions like vFunction, we can achieve better business outcomes, improve engineering efficiency, and build scalable and resilient software systems.
Addressing technical debt isn’t just about cleaning up code; it’s about ensuring long-term success and fostering innovation. I’m excited to see how these insights and strategies will help us all navigate the complexities of modern software development.
Thanks for reading, and here’s to building better software together!
