How do you keep track of mobile app development software?

If you have an existing Android project, KMP offers a unique advantage: the ability to develop for both Android and iOS platforms. One standout feature of KMP is its performance. Unlike some cross-platform solutions, KMP doesn't restrict code sharing. This means you can design and develop features natively, optimizing performance. But there's a catch: KMP's success hinges on your engineering team's capability to handle challenges. Collaboration is key, especially when iOS team members may be less familiar with Kotlin and Android development. To be clear, I'm not asserting KMP's superiority over alternatives like Flutter or React Native. The choice depends on your project's requirements and your team's expertise

I almost always start at the base level with the software. First thing's first, get the high-level picture. Using that high level & business needs I decide on either a native or cross-platform solution. That will dictate the language and some of the other tech stack. Then I find out about product delivery and other timelines, comparing that with the current hireable market to determine other things related to the stack. I almost always avoid third-party libraries, except in some use-cases, to avoid deprecation and abandonment. The only ones that make the cut are reliable, mature, and frequently maintained libraries.

Tech Stack: Understand the existing tech stack and the reasoning behind its selection. For new projects, identify and start with a suitable tech stack. Adopt second-order thinking to focus on decisions that are hard to reverse, ensuring long-term efficiency and scalability. CI/CD: Evaluate tools that enhance the development process. For fintech apps requiring additional security, consider tools like MofSF and Snyk. Tests: Writing meaningful and comprehensive tests is crucial. This practice ensures code reliability and provides confidence during both development and refactoring. Performance: Use tools within Android Studio, such as Baseline Profiling and Firebase Performance, to monitor and optimize your app's performance.

It is not easy to switch Tech Stack on developing different mobile app projects. A developer needs a certain level of framework fluency to build good apps. There would be some choices, but not in a big shift. I joined the market when cross-platform frameworks are mature, so I go with the stack. The approach helps me to focus on the business rather than the platform-specific features. But I also understand that, for some projects, developers are forced to select unfamiliar tools. So, take time to decide the stack at start is a safeguard in a long run.

To keep track of mobile app development software, regularly research and evaluate the latest tools and frameworks, and stay updated on industry trends through tech forums and news sources. Additionally, maintain a project management system to organize tasks and deadlines for efficient software development.

Using Git as your version control system is essential for modern app development. It helps you track changes in your code, making collaboration smoother by allowing multiple developers to work on the same project simultaneously without conflicts. Git’s branching and merging features let you experiment with new features without affecting the main codebase. If things go wrong, Git allows easy rollback to previous versions. Platforms like GitHub, GitLab, and Bitbucket integrate with Git, offering hosted repositories, code sharing, and reviews, making it the go-to tool for managing mobile app projects efficiently.

Version control is a must, period. With single dev projects or collaborative projects, version control solves all the problems of code storage. I personally use git command line. Sometimes, fancy UIs from github, bitbucket or gitlab make me a better day.

As your team grows, using version control tools like Bitbucket or GitHub becomes crucial, not just for tracking changes in the codebase, but also for fostering seamless collaboration and ensuring everyone is in sync. I personally lean a bit towards GitHub because of its cool built-in tools, especially GitHub Actions. Besides all the benefits, it's essential to use these platforms with security in mind. Always double-check before uploading to ensure no private info like passwords or API keys are shared. And definitely activate 2FA for an extra layer of protection.

Github.. I've use Perforce, Github, and GitLabs in the past and each and every time, Github wins. Sometimes security is a concern, but often I find that it's too much of a concern. Eg. on prem VCS. It's a pain for developers and it's security gains often don't outweigh it's cons. Some exceptions might exist for things such as banks, but for the most part any cloud based VCS is perfectly acceptable, and more than secure.

Choosing the right version control and deciding how to organise your code base is key to quickly kickoff the project and scale it. For single or few developers project, the VCS used does not matter that much. For large scale project with thousands of contributors and a large code base, having a scalable and capable VCS is key especially when you decide to have a mono-repro to leverage reusability. Regardless the VCS used, the branching flow and the the review strategy when well designed mitigate friction between contributors.

Why redo what people have done? I usually look for libraries at first, and most of the time there are libraries that solve the common problems. Second step is to check its quality, including the release cycles, the team who developed it, the number of open issues, etc. For sure, the era of downloading .jar file to import into the project has ended. Most of the frameworks nowadays packed with a dependency management tool.

In the world of mobile app development, the choice between native and third-party dependencies often depends on the project's specific needs. Some teams may prefer the convenience of third-party libraries, especially for common functionalities like networking layers, which can accelerate development. On the other hand, others might lean towards a native approach, relying solely on native technologies to maintain complete control over the codebase. Ultimately, the selection of tools and dependencies should align with your project's objectives and your team's expertise, striking a balance between efficiency and customization.

Dependency management is key to scale your app. For small to medium apps, dependency management means usually a mean to get external modules available for you in your app. For large projects with thousand of contributors, dependency management is used to modularize the app and make it possible for everyone to work on the same app at the same time and make it even possible for the compiler to compile your app in a reasonable amount of time as you start using pre-built modules. Most big tech companies will limit external dependencies for security and privacy reasons but will use extensively dependency management to design how the app is modularized.

As previously stated, I have always tried to avoid dependencies except in some cases. However, for the instances when it makes sense the default tools either NPM, SPM, Gradle, etc.. all make perfect sense. It truly depends on the tech stack as to what management tools might be used.

Dependency Managers are great tools and they work very nicely, but always tried to use my own solution and logic except in some cases whenever I had no way. Because it also make you dependent on others and sometime pushed you to the closed street. For example you have used some third party library in your project and this library not getting regular updates, So it some point your application might get crashed due to deprecation or something else then you have to remove and search for some other solution.

This one is a fun one that I recently learned a hard lesson on. I think code-quality tools should be implemented early, think ESLint or SwiftLint, SwiftFormat, and more. I find that a formatting and code duplication build process/script is hugely beneficial for not just the project but also for any new onboarded devs or mature devs alike.

For years, the boring task of formatting code manually has gone. Modern IDE can beautify the code in a click. I feel thankful for flutter_lints package, which warn me for the unconventional code in real time. Coding becomes an interesting learning process. But quality tools are just assistants. A developer needs to know what is a good architecture and a good code, then he/she can work with the tools.

Code quality may seem trivial especially when you are starting a project and you need to move fast. It turns out, starting your project by laying out the foundation for code quality generally won't take a lot of time but it would save you time and effort down the road when the project get bigger and the team scales up accordingly. Linters and different code analyzer should be setup at the land level ( commit or release of a new version ) to guarantee the quality is preserved during the lifecycle of the project.

These tools ensure that your code adheres to best practices, standards, and conventions of your chosen programming language and framework. They help detect and fix errors, bugs, vulnerabilities, and code smells, thereby improving the readability, maintainability, and performance of your code. Common code quality tools include linters, formatters, analyzers, and code review tools. For instance, SwiftLint and SwiftFormat are popular for iOS development, while more comprehensive tools like SonarQube and SonarCloud can be used across various platforms to maintain high code quality standards.

Adoto ferramentas como SwiftLint, SonarQube e CI/CD para manter o código limpo, seguro e eficiente. Um grande abra?o! Espero ter ajudado!

When I started my career, I used to think testing is a framework to let you assess and ensure the app is running as expected. Now I think about it mainly as a safeguard. When I find a bug, the immediate question is not how to fix it, the first question should be, why I don't have a test failing for this bug. Automation along with good test coverage are good tools to ensure the reliability of the app. Tests should also be diversified. From Unit tests that are very specific to end to end tests that run the app regardless of its internal implementation to integration tests, these are all important tests and engineers should invest more effort in testing which definitely will help avoid bigger issues down the road.

Testing is important, but it can only detect intentional bugs. If you know what can be wrong, you put it in the test. Automating the test reduce a lot of time and increase the confidence. In reality, many bugs arise from corner cases or from a technical debt, which is hidden under the smelly architecture or spaghetti code. It is good to add tests gradually to cover more possible bugs.

Utilise testing tools to verify the functionality, usability, and reliability of your app. These tools help prevent and identify defects, enhance user experience, and ensure quality assurance. There are various types of testing tools, including unit testing, integration testing, UI testing, performance testing, snapshot tests and security testing tools. Tools like XCTest, Espresso, Jest, Detox, and Appium can be used to automate and streamline your testing process, ensuring comprehensive coverage and efficient detection of issues.

I personally use this approach for my app development - Choosing the Right software stack is important : I use Android Studio/Kotlin for android development. For some of my apps I found cordova, react native were slow. Finding the best stack taking sometime and doing a poc with available stacks is something that you can do to finalize. All the others tools/steps without which you can't live is Git, CI/CD, Testing with Firebase through out the development cycle. Most important part is keeping track of new android stack/version releasing and doing the compatibility tests ( alpha / beta tests) using the google play console can help you building a better app.

Use deployment tools to distribute and update your app to your users. These tools help automate the build, release, and delivery processes. They also assist in monitoring and managing your app’s performance, usage, and feedback. Popular deployment tools include Fastlane, Firebase, App Center, and TestFlight, which streamline the deployment process and ensure efficient management of your app’s lifecycle.

One more thing: It may feel counterintuitive but strive to adopt SOLID architecture principles from the start of the project. Regardless of project scale and scope, adhering to these from project inception have proven, in my experience, to create the most flexible, error free and consistently on-time deliveries. ??

Continuous Integration/Continuous Deployment (CI/CD) Pipelines Implement CI/CD pipelines to automate the build, testing, and deployment processes of your mobile app. CI/CD tools like Jenkins, Travis CI, or CircleCI enable you to automatically build and test your app whenever code changes are pushed to a version control repository. This automation ensures that code changes are thoroughly tested, and successful builds can be deployed to various environments, including development, staging, and production. CI/CD pipelines help maintain code quality, reduce deployment errors, and streamline the release process.

In SW development, a solid process is the foundation for success. In my experience the delivery methodology is what ensures timely, budget-friendly, and high-quality outcomes. Drawing from years of experience managing IT development teams, I can say a successful process includes: Demand Management: Efficiently documentation of requirements and deliverables (stories, DoD, Acceptance criteria...). Continuous Development: Embracing ongoing improvement and adaptability. Quality Management: Rigorous automated testing for top-notch quality. Technical Governance: Managing architecture, APIs, and dependencies. Project Management/Governance: Meticulous planning, risk mitigation, and compliance.