I am an experienced mobile software application developer with demonstrated history of working in the Banking, Fintech, Logistics and Telecommunications Industry. Interested in the full product lifecycle from ideation to delivery. Experienced in using agile methodologies in producing high quality, scalable, and secured products across a variety of platforms. Proficient using stacks below: - Flutter - React Native - Native iOS with Swift & Objective-C - Native Android with Java & Kotlin - Kotlin Multiplatform Mobile. - CI/CD : Bitrise | Codemagic | Gitlab| AppCenter | Azure
My Mentoring Topics
- IT-Career advice
- Mobile Software Development: Dart, Flutter, JAVA, KOTLIN, SWIFT
- Profiling and Debugging Applications
- Testing & Tools: Unit, Widget and Integration Testing, LCOV,Wiremock
- State Managements
- Software Design Principles
- SOLID Design Principles
- Design architecture
- Continuous Delivery (CI/CD)
- Software Engineering
- Software Architecture
- Test-Driven Development
- generative AI
- Advancing OOP concepts
- Team Structure and Work Methodologies
- APIs
- Version Control (Git): Azure, GitHub, Gitlab
- Postman
- Code Simplicity
- Code Readability
- Security Testing
M.
26.September 2023I had the incredible fortune of being mentored by Joshua, and I can't express how grateful I am for the experience. He isn't just an Android development expert; they are a beacon of inspiration and a genuine asset to the world of tech. If you have the opportunity to learn from or work with him, consider yourself incredibly fortunate. he is not just a mentor but a game-changer. I learned more in our sessions than I could have ever hoped for, and my confidence as a developer has soared.
N.
24.September 2023I had a great session. he cleared all my doubts.he was super helpful and humble. he is the perfect mentor. he provided all the steps for my preparation.I am short of words to say thank you. thank you so much Joshua for all the help and guidance.looking forward to meeting you soon:)
Software Engineering at Google - Lessons Learned from Programming Over Time
Titus Winters, Tom Manshreck, Hyrum Wright
Key Insights from the book Culture and Values: Google's unique culture and values have a significant impact on its approach to software engineering. The company's focus on collaboration, long-term thinking, and a data-driven approach significantly influence its software development process. Codebase: Google has a single, unified codebase that allows for increased collaboration and code reuse. This requires a strong emphasis on code quality and consistency. Testing: Google places a high value on automated testing to ensure code quality. Testing is considered an essential part of the development process, not an afterthought. Code Review: Every line of code at Google is reviewed by another engineer before it is committed. This helps to maintain code quality and consistency, and promotes knowledge sharing. Scale: Google operates at an incredible scale, which presents unique challenges and requires innovative solutions. The book provides valuable insights into how Google manages this scale. Tooling: The importance of powerful, flexible tooling in software development is emphasized. Google has developed a range of tools to support its engineers and the software development process. Continuous Integration: Google follows a continuous integration model, where changes are integrated, tested, and deployed frequently. This promotes rapid feedback and allows for quick detection and fixing of issues. Technical Debt: The concept of technical debt and how Google manages it is discussed. Google aims to minimize technical debt by prioritizing clean, maintainable code and refactoring as necessary. Software Life Cycle: The book provides an in-depth look at Google's approach to the software life cycle, from initial design and development, through testing, deployment, maintenance, and eventual decommissioning. Teamwork: The importance of effective teamwork in software engineering is highlighted. Google promotes a collaborative environment where engineers work together to solve problems. An In-Depth Look at "Software Engineering at Google" The book "Software Engineering at Google" provides a comprehensive look at the unique approach to software engineering at one of the world's largest and most innovative technology companies. The book begins by discussing the culture and values at Google, which are a key driving force behind its approach to software engineering. The authors emphasize the culture of collaboration, data-driven decision making, and long-term thinking, which are all crucial in shaping their software development process. One of the most distinguishing aspects of Google's approach is its unified codebase. Unlike many other companies that have separate codebases for different projects or departments, Google has a single codebase that all engineers can access. This allows for increased collaboration, code reuse, and consistency. However, maintaining such a large and unified codebase requires strict adherence to code quality and consistency, which is enforced through rigorous code reviews and automated testing. Testing is an integral part of Google's development process, and the book provides a comprehensive overview of Google's approach to testing. The authors emphasize that testing is not an afterthought, but a fundamental part of the development process that ensures the quality of the code and prevents future issues. Code review is another important aspect of Google's approach. Every line of code that is committed to the codebase is reviewed by another engineer. This not only helps to maintain code quality and consistency, but also promotes knowledge sharing and helps to build a collective understanding of the codebase. The scale at which Google operates also presents unique challenges and requires innovative solutions. The book provides valuable insights into how Google manages the complexities and challenges of operating at such a large scale. From managing technical debt to ensuring code maintainability, the authors discuss the strategies and practices that Google employs to maintain its vast codebase and deliver high-quality software. Tooling is another key aspect highlighted in the book. The authors discuss the importance of powerful, flexible tools in supporting software development. Google has developed a range of tools to support its engineers, from code editors and compilers to continuous integration systems and code review tools. The book also covers Google's approach to continuous integration. Google follows a model where changes are integrated, tested, and deployed frequently. This promotes rapid feedback and allows for quick detection and fixing of issues. In terms of technical debt, the authors shed light on how Google manages it. The company realizes that technical debt can slow down development and make the codebase harder to understand and maintain. As such, Google prioritizes writing clean, maintainable code and frequently refactors its code to minimize technical debt. The software life cycle at Google, as described in the book, covers everything from initial design and development to testing, deployment, maintenance, and eventual decommissioning. The authors share valuable insights and lessons learned from Google's approach to managing the software life cycle. Lastly, the book emphasizes the importance of teamwork in software engineering. Google promotes a collaborative environment where engineers work together to solve problems and learn from each other. This culture of collaboration is integral to Google's success in delivering high-quality software. In conclusion, "Software Engineering at Google" provides a comprehensive, in-depth look at Google's unique approach to software engineering. It offers valuable insights and lessons that can be applied to any software development organization, regardless of size or complexity.
ViewSoftware Architecture - The Hard Parts : Modern Trade-off Analysis for Distributed Architectures
Neal Ford, Mark Richards, Pramod J. Sadalage, Zhamak Dehghani
Key Facts and Insights: The book delves into the complexity of designing modern software architectures, particularly focusing on distributed systems. It provides a comprehensive understanding of the trade-offs that need to be considered when designing and implementing a software architecture. The authors present a unique and practical approach to trade-off analysis, helping developers make informed decisions. It provides a deep understanding of the principles, techniques, and practices of modern software architecture. The book discusses the application of evolutionary architecture, a technique that allows for incrementally changing, adapting, and growing systems. It explores the role of data in distributed systems, discussing data consistency, resilience and distribution strategies. It provides practical examples and case studies to illustrate the concepts and principles discussed. It covers other important topics like microservices, Continuous Delivery, DevOps, and security in distributed systems. The book emphasizes on the importance of architectural fitness functions to ensure a system’s architecture remains consistent with its design goals. The authors discuss the impact of architectural decisions on system performance, scalability, and reliability. It presents a future-focused perspective, discussing the potential influence of emerging technologies on software architecture. In-Depth Summary and Analysis: "Software Architecture - The Hard Parts: Modern Trade-off Analysis for Distributed Architectures" is an exhaustive guide for software architects and developers navigating the complex landscape of modern distributed systems. The authors, Neal Ford, Mark Richards, Pramod J. Sadalage, and Zhamak Dehghani, bring together their vast experience and knowledge to provide a practical approach to trade-off analysis. The book begins by discussing the critical role of software architecture in system design. However, it quickly moves beyond conventional wisdom to explore the intricate challenges of distributed systems. These include the inherent trade-offs involved, such as the CAP theorem’s constraints on consistency, availability, and partition tolerance in a distributed system. The authors argue that architects must consider these trade-offs when designing systems. The authors introduce the concept of evolutionary architecture, a modern approach that favors adaptability and incremental change over rigid, upfront design. They argue that this methodology is particularly suitable for distributed systems, where requirements, technologies, and environments can change rapidly. Another significant focus of the book is data. With distributed systems, data management becomes a challenge due to consistency requirements and potential network failures. The authors discuss various data distribution strategies and their respective trade-offs, guiding architects on choosing the most suitable approach for their specific use case. The book also provides practical case studies and examples to demonstrate the application of the principles and techniques discussed. These real-world examples offer a concrete perspective, aiding the reader's understanding of complex concepts. Architectural fitness functions are another crucial topic covered. These are objective metrics that architects can use to measure whether a system is meeting its architectural goals. The authors argue for the importance of these functions in maintaining system integrity as it evolves. The book does not shy away from discussing the potential challenges and pitfalls in implementing these concepts. For example, it highlights how architectural decisions can impact system performance, scalability, and reliability. It emphasizes the need for architects to consider these effects when designing and evolving their systems. Finally, the book takes a future-focused perspective. It discusses the potential impact of emerging technologies, such as serverless architectures and blockchain, on software architecture. In conclusion, "Software Architecture - The Hard Parts: Modern Trade-off Analysis for Distributed Architectures" provides an invaluable resource for software architects and developers. It offers a comprehensive, practical, and forward-thinking approach to software architecture in the context of modern distributed systems. The book's insights, drawn from the authors' extensive experience, are sure to equip readers with the knowledge they need to design, implement, and evolve robust software architectures.
View
B.
10.October 2023I am really lucky to be mentored by him. He is a true expert when it comes to Flutter. His ability to explain complex concepts in a clear and concise manner is exceptional. What sets him apart is not just his technical expertise but also his dedication to helping his mentees succeed. He took the time to understand my specific learning goals and tailored our sessions accordingly. His patience and willingness to answer my questions, no matter how basic or advanced they may have been, made the learning process enjoyable and effective. He also pointed out the parts that can be improved in my code. All in all, I am truly grateful for our session and looking forward to the next one.